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
d59c18ac0447e598b3ff89dac490b0eaa2e0c43b6736a4a685a72c21df099156
39,322
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/ae/ae7420f427f7d4326d97a004c2446df044f58b6a_Cronjeshare.sol
4,982
19,759
// https://app.cronjetomb.finance/ // https://docs.cronjetomb.finance/ // 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 = 50; string private _name = "Cronje Share"; string private _symbol = "CSHARE"; 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")); } } // Cronjeshare with Governance. contract Cronjeshare is BEP20("Cronjeshare", "CSHARE") { /// @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; } }
312,123
11,800
c8429e4a467309d4a960da1444d71d8d07f8a30d8680bca66860ba71e7555a8d
15,323
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xfaa68bca10f557ad760f07c81ae15bc3d9aa4231.sol
2,772
10,267
pragma solidity ^0.4.19; // File: zeppelin-solidity/contracts/math/SafeMath.sol library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } // File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } // File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); // SafeMath.sub will throw if there is not enough balance. balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } // File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } // File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } // File: contracts/DisableSelfTransfer.sol contract DisableSelfTransfer is StandardToken { function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(this)); return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(this)); return super.transferFrom(_from, _to, _value); } } // File: zeppelin-solidity/contracts/ownership/Ownable.sol contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } // File: contracts/OwnerContract.sol contract OwnerContract is Ownable { mapping (address => bool) internal contracts; // New modifier to be used in place of OWNER ONLY activity // Eventually this will be owned by a controller contract and not a private wallet // (Voting needs to be implemented) modifier justOwner() { require(msg.sender == owner); _; } // Allow contracts to have ownership without taking full custody of the token // (Until voting is fully implemented) modifier onlyOwner() { if (msg.sender == address(0) || (msg.sender != owner && !contracts[msg.sender])) { revert(); // error for uncontrolled request } _; } // Stops owner from gaining access to all functionality modifier onlyContract() { require(msg.sender != address(0)); require(contracts[msg.sender]); _; } // new owner only activity. // (Voting to be implemented for owner replacement) function removeController(address controllerToRemove) public justOwner { require(contracts[controllerToRemove]); contracts[controllerToRemove] = false; } // new owner only activity. // (Voting to be implemented for owner replacement) function addController(address newController) public justOwner { contracts[newController] = true; } } // File: zeppelin-solidity/contracts/token/ERC20/BurnableToken.sol contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) 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); } } // File: zeppelin-solidity/contracts/token/ERC20/MintableToken.sol contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } // File: contracts/MintableContractOwnerToken.sol contract MintableContractOwnerToken is MintableToken, BurnableToken, OwnerContract, DisableSelfTransfer { bool burnAllowed = false; // Fired when an approved contract calls restartMint event MintRestarted(); // Fired when a transfer is initiated from the contract rather than the owning wallet. event ContractTransfer(address from, address to, uint value); // Fired when burning status changes event BurningStateChange(bool canBurn); // opposite of canMint used for restarting the mint modifier cantMint() { require(mintingFinished); _; } // Require Burn to be turned on modifier canBurn() { require(burnAllowed); _; } // Require that burning is turned off modifier cantBurn() { require(!burnAllowed); _; } // Enable Burning Only if Burning is Off function enableBurning() public onlyContract cantBurn { burnAllowed = true; BurningStateChange(burnAllowed); } // Disable Burning Only if Burning is On function disableBurning() public onlyContract canBurn { burnAllowed = false; BurningStateChange(burnAllowed); } // Override parent burn function to provide canBurn limitation function burn(uint256 _value) public canBurn { super.burn(_value); } // Allow the contract to approve the mint restart // (Voting will be essential in these actions) function restartMinting() onlyContract cantMint public returns (bool) { mintingFinished = false; MintRestarted(); // Notify the blockchain that the coin minting was restarted return true; } // Allow owner or contract to finish minting. function finishMinting() onlyOwner canMint public returns (bool) { return super.finishMinting(); } // Allow the system to create transactions for transfers when appropriate. // (e.g. upgrading the token for everyone, voting to recover accounts for lost private keys, // (Must be voted for on an approved contract to gain access to this function) function contractTransfer(address _from, address _to, uint256 _value) public onlyContract returns (bool) { require(_from != address(0)); require(_to != address(0)); require(_value > 0); require(_value <= balances[_from]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); ContractTransfer(_from, _to, _value); // Notify blockchain the following transaction was contract initiated Transfer(_from, _to, _value); // Call original transfer event to maintain compatibility with stardard transaction systems return true; } } // File: contracts/LazyCoderCoin.sol contract LazyCoderCoin is MintableContractOwnerToken { string public name = "LazyCoder Coin"; string public symbol = "TLC"; uint8 public decimals = 18; function LazyCoderCoin() public { } }
208,596
11,801
2b9e8642ff0fce6988c41e95ab838ef63296ed91da23704230f479bee890492d
9,457
.sol
Solidity
false
449763406
joswha/Replaying-ETH-Attacks
7ee09cebb752cbac399c9ad08743444353fe9c31
contracts/powh/PonziTokenV3.sol
3,310
9,107
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 PonziTokenV3 { 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 = "ProofOfWeakHands"; string constant public symbol = "POWH"; 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 PonziTokenV3() 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 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); } }
259,202
11,802
7f2dfbe6f8e81f3986eee5cb3166db8515d08423fd57c4677b75c6ee845e44f0
17,121
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x3c3f82ea193535e4e94dfbce8ac771f361cfedd6.sol
3,155
11,603
pragma solidity ^0.4.23; // File: contracts/helpers/Ownable.sol contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } // File: contracts/helpers/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/token/ERC20Interface.sol contract ERC20Interface { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); function transferFrom(address from, address to, uint256 value) public returns (bool); function allowance(address owner, address spender) public view returns (uint256); } // File: contracts/token/BaseToken.sol contract BaseToken is ERC20Interface { using SafeMath for uint256; mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) internal allowed; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } 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); emit 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) { 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 allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) { 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; } } // File: contracts/token/MintableToken.sol contract MintableToken is BaseToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { require(_to != address(0)); totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } // File: contracts/token/CappedToken.sol contract CappedToken is MintableToken { uint256 public cap; constructor(uint256 _cap) public { require(_cap > 0); cap = _cap; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { require(totalSupply_.add(_amount) <= cap); return super.mint(_to, _amount); } } // File: contracts/helpers/Pausable.sol contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } // File: contracts/token/PausableToken.sol contract PausableToken is BaseToken, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } // File: contracts/token/SignedTransferToken.sol contract SignedTransferToken is BaseToken { event TransferPreSigned(address indexed from, address indexed to, address indexed settler, uint256 value, uint256 fee); // Mapping of already executed settlements for a given address mapping(address => mapping(bytes32 => bool)) internal executedSettlements; function transferPreSigned(address _from, address _to, uint256 _value, uint256 _fee, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public returns (bool) { uint256 total = _value.add(_fee); bytes32 calcHash = calculateHash(_from, _to, _value, _fee, _nonce); require(_to != address(0)); require(isValidSignature(_from, calcHash, _v, _r, _s)); require(balances[_from] >= total); require(!executedSettlements[_from][calcHash]); executedSettlements[_from][calcHash] = true; // Move tokens balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); // Move fee balances[_from] = balances[_from].sub(_fee); balances[msg.sender] = balances[msg.sender].add(_fee); emit Transfer(_from, msg.sender, _fee); emit TransferPreSigned(_from, _to, msg.sender, _value, _fee); return true; } function transferPreSignedBulk(address[] _from, address[] _to, uint256[] _values, uint256[] _fees, uint256[] _nonces, uint8[] _v, bytes32[] _r, bytes32[] _s) public returns (bool) { // Make sure all the arrays are of the same length require(_from.length == _to.length && _to.length ==_values.length && _values.length == _fees.length && _fees.length == _nonces.length && _nonces.length == _v.length && _v.length == _r.length && _r.length == _s.length); for(uint i; i < _from.length; i++) { transferPreSigned(_from[i], _to[i], _values[i], _fees[i], _nonces[i], _v[i], _r[i], _s[i]); } return true; } function calculateHash(address _from, address _to, uint256 _value, uint256 _fee, uint256 _nonce) public view returns (bytes32) { return keccak256(abi.encodePacked(uint256(0), address(this), _from, _to, _value, _fee, _nonce)); } function isValidSignature(address _signer, bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (bool) { return _signer == ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _hash)), _v, _r, _s); } function isTransactionAlreadySettled(address _from, bytes32 _calcHash) public view returns (bool) { return executedSettlements[_from][_calcHash]; } } // File: contracts/token/PausableSignedTransferToken.sol contract PausableSignedTransferToken is SignedTransferToken, PausableToken { function transferPreSigned(address _from, address _to, uint256 _value, uint256 _fee, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public whenNotPaused returns (bool) { return super.transferPreSigned(_from, _to, _value, _fee, _nonce, _v, _r, _s); } function transferPreSignedBulk(address[] _from, address[] _to, uint256[] _values, uint256[] _fees, uint256[] _nonces, uint8[] _v, bytes32[] _r, bytes32[] _s) public whenNotPaused returns (bool) { return super.transferPreSignedBulk(_from, _to, _values, _fees, _nonces, _v, _r, _s); } } // File: contracts/ElesToken.sol contract ElesToken is CappedToken, PausableSignedTransferToken { string public name = 'Elements Estates Token'; string public symbol = 'ELES'; uint256 public decimals = 18; // Max supply of 250 million uint256 internal maxSupply = 250000000 * 10**decimals; constructor() CappedToken(maxSupply) public { paused = true; } // @dev Recover any mistakenly sent ERC20 tokens to the Token address function recoverERC20Tokens(address _erc20, uint256 _amount) public onlyOwner { ERC20Interface(_erc20).transfer(msg.sender, _amount); } }
213,871
11,803
ae27a79fb90b326e92316a25798e2a488092eba325d97003a26042b77485f1c9
17,369
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/12/124b4276d44b4e3e9e5a3ac06a1cacdd36ff053b_Distributor.sol
3,392
13,870
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.5; library LowGasSafeMath { /// @notice Returns x + y, reverts if sum overflows uint256 /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x + y) >= x); } function add32(uint32 x, uint32 y) internal pure returns (uint32 z) { require((z = x + y) >= x); } /// @notice Returns x - y, reverts if underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(uint256 x, uint256 y) internal pure returns (uint256 z) { require((z = x - y) <= x); } function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) { require((z = x - y) <= x); } /// @notice Returns x * y, reverts if overflows /// @param x The multiplicand /// @param y The multiplier /// @return z The product of x and y function mul(uint256 x, uint256 y) internal pure returns (uint256 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } function div(uint256 x, uint256 y) internal pure returns(uint256 z){ require(y > 0); z=x/y; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function addressToString(address _address) internal pure returns(string memory) { bytes32 _bytes = bytes32(uint256(_address)); bytes memory HEX = "0123456789abcdef"; bytes memory _addr = new bytes(42); _addr[0] = '0'; _addr[1] = 'x'; for(uint256 i = 0; i < 20; i++) { _addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)]; _addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)]; } return string(_addr); } } contract OwnableData { address public owner; address public pendingOwner; } contract Ownable is OwnableData { event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /// @notice `owner` defaults to msg.sender on construction. constructor() { owner = msg.sender; emit OwnershipTransferred(address(0), msg.sender); } /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner. /// Can only be invoked by the current `owner`. /// @param newOwner Address of the new owner. function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner { if (direct) { // Checks require(newOwner != address(0) || renounce, "Ownable: zero address"); // Effects emit OwnershipTransferred(owner, newOwner); owner = newOwner; pendingOwner = address(0); } else { // Effects pendingOwner = newOwner; } } /// @notice Needs to be called by `pendingOwner` to claim ownership. function claimOwnership() public { address _pendingOwner = pendingOwner; // Checks require(msg.sender == _pendingOwner, "Ownable: caller != pending owner"); // Effects emit OwnershipTransferred(owner, _pendingOwner); owner = _pendingOwner; pendingOwner = address(0); } /// @notice Only allows the `owner` to execute the function. modifier onlyOwner() { require(msg.sender == owner, "Ownable: caller is not the owner"); _; } } interface ITreasury { function mintRewards(address _recipient, uint _amount) external; } contract Distributor is Ownable { using LowGasSafeMath for uint; using LowGasSafeMath for uint32; IERC20 public immutable TIME; ITreasury public immutable treasury; uint32 public immutable epochLength; uint32 public nextEpochTime; mapping(uint => Adjust) public adjustments; event LogDistribute(address indexed recipient, uint amount); event LogAdjust(uint initialRate, uint currentRate, uint targetRate); event LogAddRecipient(address indexed recipient, uint rate); event LogRemoveRecipient(address indexed recipient); struct Info { uint rate; // in ten-thousandths (5000 = 0.5%) address recipient; } Info[] public info; struct Adjust { bool add; uint rate; uint target; } constructor(address _treasury, address _time, uint32 _epochLength, uint32 _nextEpochTime) { require(_treasury != address(0)); treasury = ITreasury(_treasury); require(_time != address(0)); TIME = IERC20(_time); epochLength = _epochLength; nextEpochTime = _nextEpochTime; } function distribute() external returns (bool) { if (nextEpochTime <= uint32(block.timestamp)) { nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time // distribute rewards to each recipient for (uint i = 0; i < info.length; i++) { if (info[ i ].rate > 0) { treasury.mintRewards(// mint and send from treasury info[ i ].recipient, nextRewardAt(info[ i ].rate)); adjust(i); // check for adjustment } emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate)); } return true; } else { return false; } } function adjust(uint _index) internal { Adjust memory adjustment = adjustments[ _index ]; if (adjustment.rate != 0) { uint initial = info[ _index ].rate; uint rate = initial; if (adjustment.add) { // if rate should increase rate = rate.add(adjustment.rate); // raise rate if (rate >= adjustment.target) { // if target met rate = adjustment.target; delete adjustments[ _index ]; } } else { // if rate should decrease rate = rate.sub(adjustment.rate); // lower rate if (rate <= adjustment.target) { // if target met rate = adjustment.target; delete adjustments[ _index ]; } } info[ _index ].rate = rate; emit LogAdjust(initial, rate, adjustment.target); } } function nextRewardAt(uint _rate) public view returns (uint) { return TIME.totalSupply().mul(_rate).div(1000000); } function nextRewardFor(address _recipient) external view returns (uint) { uint reward; for (uint i = 0; i < info.length; i++) { if (info[ i ].recipient == _recipient) { reward = nextRewardAt(info[ i ].rate); } } return reward; } function addRecipient(address _recipient, uint _rewardRate) external onlyOwner { require(_recipient != address(0), "IA"); require(_rewardRate <= 5000, "Too high reward rate"); require(info.length <= 4, "limit recipients max to 5"); info.push(Info({ recipient: _recipient, rate: _rewardRate })); emit LogAddRecipient(_recipient, _rewardRate); } function removeRecipient(uint _index, address _recipient) external onlyOwner { require(_recipient == info[ _index ].recipient, "NA"); info[_index] = info[info.length-1]; adjustments[_index] = adjustments[ info.length-1 ]; info.pop(); delete adjustments[ info.length-1 ]; emit LogRemoveRecipient(_recipient); } function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner { require(_target <= 5000, "Too high reward rate"); adjustments[ _index ] = Adjust({ add: _add, rate: _rate, target: _target }); } }
84,635
11,804
5c5f7e39c9128be9d266fa2c358be611faf034834558c08cea55393d68dd64c9
29,512
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/7b/7bf1446b3b41271031950303670b7bbb39638747_SAITAMA.sol
5,182
18,686
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 SAITAMA is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; mapping (address => bool) public isAllowed; address[] private _excluded; uint8 private constant _decimals = 18; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'SAITAMA'; string private constant _symbol = 'SAITAMA'; uint256 private _taxFee = 400; uint256 private _burnFee = 0; uint public max_tx_size = 1000 ether; bool public isPaused = false; constructor () public { _rOwned[_msgSender()] = _rTotal; isAllowed[_msgSender()] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function toggleAllowed(address addr) external onlyOwner { isAllowed[addr] = !isAllowed[addr]; } function unpause() external returns (bool){ require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call"); isPaused = false; return true; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0x708BBb821d88517f671B220BF4f0C3462B2c2EA1, '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; } }
330,030
11,805
a28a814f0dc9ebbf4563962089303f26cc28bd1e9d312842976890e51788ef1d
9,324
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x495c0c519a8d8f171a8952fc0e97a7c354685ab7.sol
2,246
8,556
pragma solidity ^0.4.25; 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; } } /// @title Role based access control mixin for Rasmart Platform /// @author Mai Abha <maiabha82@gmail.com> /// @dev Ignore DRY approach to achieve readability contract RBACMixin { /// @notice Constant string message to throw on lack of access string constant FORBIDDEN = "Haven't enough right to access"; /// @notice Public map of owners mapping (address => bool) public owners; /// @notice Public map of minters mapping (address => bool) public minters; /// @notice The event indicates the addition of a new owner /// @param who is address of added owner event AddOwner(address indexed who); /// @notice The event indicates the deletion of an owner /// @param who is address of deleted owner event DeleteOwner(address indexed who); /// @notice The event indicates the addition of a new minter /// @param who is address of added minter event AddMinter(address indexed who); /// @notice The event indicates the deletion of a minter /// @param who is address of deleted minter event DeleteMinter(address indexed who); constructor () public { _setOwner(msg.sender, true); } /// @notice The functional modifier rejects the interaction of senders who are not owners modifier onlyOwner() { require(isOwner(msg.sender), FORBIDDEN); _; } /// @notice Functional modifier for rejecting the interaction of senders that are not minters modifier onlyMinter() { require(isMinter(msg.sender), FORBIDDEN); _; } /// @notice Look up for the owner role on providen address /// @param _who is address to look up /// @return A boolean of owner role function isOwner(address _who) public view returns (bool) { return owners[_who]; } /// @notice Look up for the minter role on providen address /// @param _who is address to look up /// @return A boolean of minter role function isMinter(address _who) public view returns (bool) { return minters[_who]; } /// @notice Adds the owner role to provided address /// @dev Requires owner role to interact /// @param _who is address to add role /// @return A boolean that indicates if the operation was successful. function addOwner(address _who) public onlyOwner returns (bool) { _setOwner(_who, true); } /// @notice Deletes the owner role to provided address /// @dev Requires owner role to interact /// @param _who is address to delete role /// @return A boolean that indicates if the operation was successful. function deleteOwner(address _who) public onlyOwner returns (bool) { _setOwner(_who, false); } /// @notice Adds the minter role to provided address /// @dev Requires owner role to interact /// @param _who is address to add role /// @return A boolean that indicates if the operation was successful. function addMinter(address _who) public onlyOwner returns (bool) { _setMinter(_who, true); } /// @notice Deletes the minter role to provided address /// @dev Requires owner role to interact /// @param _who is address to delete role /// @return A boolean that indicates if the operation was successful. function deleteMinter(address _who) public onlyOwner returns (bool) { _setMinter(_who, false); } /// @notice Changes the owner role to provided address /// @param _who is address to change role /// @param _flag is next role status after success /// @return A boolean that indicates if the operation was successful. function _setOwner(address _who, bool _flag) private returns (bool) { require(owners[_who] != _flag); owners[_who] = _flag; if (_flag) { emit AddOwner(_who); } else { emit DeleteOwner(_who); } return true; } /// @notice Changes the minter role to provided address /// @param _who is address to change role /// @param _flag is next role status after success /// @return A boolean that indicates if the operation was successful. function _setMinter(address _who, bool _flag) private returns (bool) { require(minters[_who] != _flag); minters[_who] = _flag; if (_flag) { emit AddMinter(_who); } else { emit DeleteMinter(_who); } return true; } } interface IMintableToken { function mint(address _to, uint256 _amount) external returns (bool); } /// @title Very simplified implementation of Token Bucket Algorithm to secure token minting /// @author Mai Abha <maiabha82@gmail.com> /// @notice Works with tokens implemented Mintable interface contract AdvisorsBucket is RBACMixin, IMintableToken { using SafeMath for uint; /// @notice Limit maximum amount of available for minting tokens when bucket is full uint256 public size; /// @notice Bucket refill rate uint256 public rate; /// @notice Stored time of latest minting /// @dev Each successful call of minting function will update field with call timestamp uint256 public lastMintTime; /// @notice Left tokens in bucket on time of latest minting uint256 public leftOnLastMint; /// @notice Reference of Mintable token /// @dev Setup in contructor phase and never change in future IMintableToken public token; /// @notice Token Bucket leak event fires on each minting /// @param to is address of target tokens holder /// @param left is amount of tokens available in bucket after leak event Leak(address indexed to, uint256 left); /// @param _token is address of Mintable token /// @param _size initial size of token bucket /// @param _rate initial refill rate (tokens/sec) constructor (address _token, uint256 _size, uint256 _rate) public { token = IMintableToken(_token); size = _size; rate = _rate; leftOnLastMint = _size; } /// @notice Change size of bucket /// @dev Require owner role to call /// @param _size is new size of bucket /// @return A boolean that indicates if the operation was successful. function setSize(uint256 _size) public onlyOwner returns (bool) { size = _size; return true; } /// @notice Change refill rate of bucket /// @dev Require owner role to call /// @param _rate is new refill rate of bucket /// @return A boolean that indicates if the operation was successful. function setRate(uint256 _rate) public onlyOwner returns (bool) { rate = _rate; return true; } /// @notice Change size and refill rate of bucket /// @dev Require owner role to call /// @param _size is new size of bucket /// @param _rate is new refill rate of bucket /// @return A boolean that indicates if the operation was successful. function setSizeAndRate(uint256 _size, uint256 _rate) public onlyOwner returns (bool) { return setSize(_size) && setRate(_rate); } /// @notice Function to mint tokens /// @param _to The address that will receive the minted tokens. /// @param _amount The amount of tokens to mint. /// @return A boolean that indicates if the operation was successful. function mint(address _to, uint256 _amount) public onlyMinter returns (bool) { uint256 available = availableTokens(); require(_amount <= available); leftOnLastMint = available.sub(_amount); lastMintTime = now; // solium-disable-line security/no-block-members require(token.mint(_to, _amount)); return true; } /// @notice Function to calculate and get available in bucket tokens /// @return An amount of available tokens in bucket function availableTokens() public view returns (uint) { // solium-disable-next-line security/no-block-members uint256 timeAfterMint = now.sub(lastMintTime); uint256 refillAmount = rate.mul(timeAfterMint).add(leftOnLastMint); return size < refillAmount ? size : refillAmount; } }
185,927
11,806
4b0270a91dec41a8733d855d9d0c0686aa3c0364102c42d0f674c188824393d6
10,872
.sol
Solidity
false
360539372
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
1d65472e1c546af6781cb17991843befc635a28e
dataset/dapp_contracts/High-risk/0xB3DD9429035c29CC787d50ffcd14dE9E35657c9D.sol
3,627
10,459
pragma solidity >= 0.6.3 < 0.7.0; contract EthernityMoney { address public creator; uint MAX_LEVEL = 9; uint REFERRALS_LIMIT = 2; uint LEVEL_EXPIRE_TIME = 111 days; uint LEVEL_HIGHER_FOUR_EXPIRE_TIME = 10000 days; mapping (address => User) public users; mapping (uint => address) public userAddresses; uint public last_uid; mapping (uint => uint) public levelPrice; mapping (uint => uint) public uplinesToRcvEth; mapping (address => ProfitsRcvd) public rcvdProfits; mapping (address => ProfitsGiven) public givenProfits; mapping (address => LostProfits) public lostProfits; struct User { uint id; uint referrerID; address[] referrals; mapping (uint => uint) levelExpiresAt; } struct ProfitsRcvd { uint uid; uint[] fromId; address[] fromAddr; uint[] amount; } struct LostProfits { uint uid; uint[] toId; address[] toAddr; uint[] amount; uint[] level; } struct ProfitsGiven { uint uid; uint[] toId; address[] toAddr; uint[] amount; uint[] level; uint[] line; } modifier validLevelAmount(uint _level) { require(msg.value == levelPrice[_level], 'Invalid level amount sent'); _; } modifier userRegistered() { require(users[msg.sender].id != 0, 'User does not exist'); _; } modifier validReferrerID(uint _referrerID) { require(_referrerID > 0 && _referrerID <= last_uid, 'Invalid referrer ID'); _; } modifier userNotRegistered() { require(users[msg.sender].id == 0, 'User is already registered'); _; } modifier validLevel(uint _level) { require(_level > 0 && _level <= MAX_LEVEL, 'Invalid level entered'); _; } event RegisterUserEvent(address indexed user, address indexed referrer, uint time); event BuyLevelEvent(address indexed user, uint indexed level, uint time); event GetLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time); event LostLevelProfitEvent(address indexed user, address indexed referral, uint indexed level, uint time); constructor() public { last_uid++; creator = msg.sender; levelPrice[1] = 0.30 ether; levelPrice[2] = 0.72 ether; levelPrice[3] = 1.96 ether; levelPrice[4] = 4.00 ether; levelPrice[5] = 8.10 ether; levelPrice[6] = 15.00 ether; levelPrice[7] = 20.90 ether; levelPrice[8] = 35.40 ether; levelPrice[9] = 50.70 ether; uplinesToRcvEth[1] = 5; uplinesToRcvEth[2] = 6; uplinesToRcvEth[3] = 7; uplinesToRcvEth[4] = 8; uplinesToRcvEth[5] = 9; uplinesToRcvEth[6] = 10; uplinesToRcvEth[7] = 11; uplinesToRcvEth[8] = 12; uplinesToRcvEth[9] = 13; users[creator] = User({ id: last_uid, referrerID: 0, referrals: new address[](0) }); userAddresses[last_uid] = creator; for (uint i = 1; i <= MAX_LEVEL; i++) { users[creator].levelExpiresAt[i] = 1 << 37; } } function registerUser(uint _referrerID) public payable userNotRegistered() validReferrerID(_referrerID) validLevelAmount(1) { uint _level = 1; if (users[userAddresses[_referrerID]].referrals.length >= REFERRALS_LIMIT) { _referrerID = users[findReferrer(userAddresses[_referrerID])].id; } last_uid++; users[msg.sender] = User({ id: last_uid, referrerID: _referrerID, referrals: new address[](0) }); userAddresses[last_uid] = msg.sender; users[msg.sender].levelExpiresAt[_level] = now + getLevelExpireTime(_level); users[userAddresses[_referrerID]].referrals.push(msg.sender); transferLevelPayment(_level, msg.sender); emit RegisterUserEvent(msg.sender, userAddresses[_referrerID], now); } function buyLevel(uint _level) public payable userRegistered() validLevel(_level) validLevelAmount(_level) { for (uint l = _level - 1; l > 0; l--) { require(getUserLevelExpiresAt(msg.sender, l) >= now, 'Buy previous level first'); } if (getUserLevelExpiresAt(msg.sender, _level) == 0) { users[msg.sender].levelExpiresAt[_level] = now + getLevelExpireTime(_level); } else { users[msg.sender].levelExpiresAt[_level] += getLevelExpireTime(_level); } transferLevelPayment(_level, msg.sender); emit BuyLevelEvent(msg.sender, _level, now); } function getLevelExpireTime(uint _level) public view returns (uint) { if (_level < 5) { return LEVEL_EXPIRE_TIME; } else { return LEVEL_HIGHER_FOUR_EXPIRE_TIME; } } function findReferrer(address _user) public view returns (address) { if (users[_user].referrals.length < REFERRALS_LIMIT) { return _user; } address[1632] memory referrals; referrals[0] = users[_user].referrals[0]; referrals[1] = users[_user].referrals[1]; address referrer; for (uint i = 0; i < 16382; i++) { if (users[referrals[i]].referrals.length < REFERRALS_LIMIT) { referrer = referrals[i]; break; } if (i >= 8191) { continue; } referrals[(i+1)*2] = users[referrals[i]].referrals[0]; referrals[(i+1)*2+1] = users[referrals[i]].referrals[1]; } require(referrer != address(0), 'Referrer not found'); return referrer; } function transferLevelPayment(uint _level, address _user) internal { uint height = _level; address referrer = getUserUpline(_user, height); if (referrer == address(0)) { referrer = creator; } uint uplines = uplinesToRcvEth[_level]; bool chkLostProfit = false; address lostAddr; for (uint i = 1; i <= uplines; i++) { referrer = getUserUpline(_user, i); if(chkLostProfit){ lostProfits[lostAddr].uid = users[referrer].id; lostProfits[lostAddr].toId.push(users[referrer].id); lostProfits[lostAddr].toAddr.push(referrer); lostProfits[lostAddr].amount.push(levelPrice[_level] / uplinesToRcvEth[_level]); lostProfits[lostAddr].level.push(getUserLevel(referrer)); chkLostProfit = false; emit LostLevelProfitEvent(referrer, msg.sender, _level, 0); } if (referrer != address(0) && (users[_user].levelExpiresAt[_level] == 0 || getUserLevelExpiresAt(referrer, _level) < now)) { chkLostProfit = true; uplines++; lostAddr = referrer; continue; } else { chkLostProfit = false; } if (referrer == address(0)) { referrer = creator; } if (address(uint160(referrer)).send(msg.value / uplinesToRcvEth[_level])) { rcvdProfits[referrer].uid = users[referrer].id; rcvdProfits[referrer].fromId.push(users[msg.sender].id); rcvdProfits[referrer].fromAddr.push(msg.sender); rcvdProfits[referrer].amount.push(levelPrice[_level] / uplinesToRcvEth[_level]); givenProfits[msg.sender].uid = users[msg.sender].id; givenProfits[msg.sender].toId.push(users[referrer].id); givenProfits[msg.sender].toAddr.push(referrer); givenProfits[msg.sender].amount.push(levelPrice[_level] / uplinesToRcvEth[_level]); givenProfits[msg.sender].level.push(getUserLevel(referrer)); givenProfits[msg.sender].line.push(i); emit GetLevelProfitEvent(referrer, msg.sender, _level, now); } } } function getUserUpline(address _user, uint height) public view returns (address) { if (height <= 0 || _user == address(0)) { return _user; } return this.getUserUpline(userAddresses[users[_user].referrerID], height - 1); } function getUserReferrals(address _user) public view returns (address[] memory) { return users[_user].referrals; } function getUserProfitsFromId(address _user) public view returns (uint[] memory) { return rcvdProfits[_user].fromId; } function getUserProfitsFromAddr(address _user) public view returns (address[] memory) { return rcvdProfits[_user].fromAddr; } function getUserProfitsAmount(address _user) public view returns (uint256[] memory) { return rcvdProfits[_user].amount; } function getUserProfitsGivenToId(address _user) public view returns (uint[] memory) { return givenProfits[_user].toId; } function getUserProfitsGivenToAddr(address _user) public view returns (address[] memory) { return givenProfits[_user].toAddr; } function getUserProfitsGivenToAmount(address _user) public view returns (uint[] memory) { return givenProfits[_user].amount; } function getUserProfitsGivenToLevel(address _user) public view returns (uint[] memory) { return givenProfits[_user].level; } function getUserProfitsGivenToLine(address _user) public view returns (uint[] memory) { return givenProfits[_user].line; } function getUserLostsToId(address _user) public view returns (uint[] memory) { return (lostProfits[_user].toId); } function getUserLostsToAddr(address _user) public view returns (address[] memory) { return (lostProfits[_user].toAddr); } function getUserLostsAmount(address _user) public view returns (uint[] memory) { return (lostProfits[_user].amount); } function getUserLostsLevel(address _user) public view returns (uint[] memory) { return (lostProfits[_user].level); } function getUserLevelExpiresAt(address _user, uint _level) public view returns (uint) { return users[_user].levelExpiresAt[_level]; } function getUserLevel (address _user) public view returns (uint) { if (getUserLevelExpiresAt(_user, 1) < now) { return (0); } else if (getUserLevelExpiresAt(_user, 2) < now) { return (1); } else if (getUserLevelExpiresAt(_user, 3) < now) { return (2); } else if (getUserLevelExpiresAt(_user, 4) < now) { return (3); } else if (getUserLevelExpiresAt(_user, 5) < now) { return (4); } else if (getUserLevelExpiresAt(_user, 6) < now) { return (5); } else if (getUserLevelExpiresAt(_user, 7) < now) { return (6); } else if (getUserLevelExpiresAt(_user, 8) < now) { return (7); } else if (getUserLevelExpiresAt(_user, 9) < now) { return (8); } else if (getUserLevelExpiresAt(_user, 10) < now) { return (9); } } function getUserDetails (address _user) public view returns (uint, uint) { if (getUserLevelExpiresAt(_user, 1) < now) { return (1, users[_user].id); } else if (getUserLevelExpiresAt(_user, 2) < now) { return (2, users[_user].id); } else if (getUserLevelExpiresAt(_user, 3) < now) { return (3, users[_user].id); } else if (getUserLevelExpiresAt(_user, 4) < now) { return (4, users[_user].id); } else if (getUserLevelExpiresAt(_user, 5) < now) { return (5, users[_user].id); } else if (getUserLevelExpiresAt(_user, 6) < now) { return (6, users[_user].id); } else if (getUserLevelExpiresAt(_user, 7) < now) { return (7, users[_user].id); } else if (getUserLevelExpiresAt(_user, 8) < now) { return (8, users[_user].id); } else if (getUserLevelExpiresAt(_user, 9) < now) { return (9, users[_user].id); } } receive() external payable { revert(); } }
336,024
11,807
ba7e2a7d91cc5d9cfc1f9a4ec02365727ba46f2ac4c396e18e0af18da167fd20
39,220
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/1b/1b0f26a18c1bc6c08b3f5f9d0371e118fe75dabc_ape.sol
4,951
19,661
// 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 = 2000; string private _name = "Fantom Ape"; string private _symbol = "APE"; 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")); } } // ape with Governance. contract ape is BEP20("Fantom APE", "APE") { /// @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; } }
331,545
11,808
813f0048f13b4a379444ce5acde241489fbf97f68c0b02afbb44300a5a2a222c
22,525
.sol
Solidity
false
388150634
candlegenie/solidity
99c25153b82e4295145234049d0a967dcba26c18
CandleGeniePredictions.sol
4,679
19,169
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; //CONTEXT abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return payable(msg.sender); } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } // REENTRANCY GUARD 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; } } //OWNABLE abstract contract Ownable is Context { address public _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 OwnershipRenounce() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function OwnershipTransfer(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } //PAUSABLE 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()); } } //PREDICTIONS contract CandleGeniePredictionV3 is Ownable, Pausable, ReentrancyGuard { struct Round { uint256 epoch; uint256 bullAmount; uint256 bearAmount; uint256 rewardBaseCalAmount; uint256 rewardAmount; int256 lockPrice; int256 closePrice; uint32 startTimestamp; uint32 lockTimestamp; uint32 closeTimestamp; uint32 lockPriceTimestamp; uint32 closePriceTimestamp; bool closed; bool cancelled; } enum Position {Bull, Bear} struct BetInfo { Position position; uint256 amount; bool claimed; // default false } mapping(uint256 => Round) public Rounds; mapping(uint256 => mapping(address => BetInfo)) public Bets; mapping(address => uint256[]) public UserBets; mapping(address=>bool) internal Blacklist; uint256 public currentEpoch; address public operatorAddress; string public priceSource; // Defaults uint256 public rewardRate = 97; // Prize reward rate uint256 constant internal minimumRewardRate = 90; // Minimum reward rate 90% uint256 public intervalSeconds = 300; uint256 public minBetAmount = 1000000000000000; uint256 public bufferSeconds = 30; bool public startOnce = false; bool public lockOnce = false; event BetBear(address indexed sender, uint256 indexed epoch, uint256 amount); event BetBull(address indexed sender, uint256 indexed epoch, uint256 amount); event HouseBet(address indexed sender, uint256 indexed epoch, uint256 bullAmount, uint256 bearAmount); event LockRound(uint256 indexed epoch, int256 price, uint32 timestamp); event EndRound(uint256 indexed epoch, int256 price, uint32 timestamp); event Claim(address indexed sender, uint256 indexed epoch, uint256 amount); event StartRound(uint256 indexed epoch); event CancelRound(uint256 indexed epoch); event Pause(uint256 indexed epoch); event Unpause(uint256 indexed epoch); event RewardsCalculated(uint256 indexed epoch, uint256 rewardBaseCalAmount, uint256 rewardAmount); event InjectFunds(address indexed sender); event MinBetAmountUpdated(uint256 indexed epoch, uint256 minBetAmount); event BufferAndIntervalSecondsUpdated(uint256 bufferSeconds, uint256 intervalSeconds); event NewPriceSource(string priceSource); constructor(address _operatorAddress) { operatorAddress = _operatorAddress; } modifier onlyOwnerOrOperator() { require(msg.sender == _owner || msg.sender == operatorAddress, "Only owner or operator can call this function"); _; } modifier notContract() { require(!_isContract(msg.sender), "contract not allowed"); require(msg.sender == tx.origin, "proxy contract not allowed"); _; } // INTERNAL FUNCTIONS ----------------> function _safeStartRound(uint256 epoch) internal { Round storage round = Rounds[epoch]; round.startTimestamp = uint32(block.timestamp); round.lockTimestamp = uint32(block.timestamp + intervalSeconds); round.closeTimestamp = uint32(block.timestamp + (2 * intervalSeconds)); round.epoch = epoch; emit StartRound(epoch); } function _safeLockRound(uint256 epoch, int256 price, uint32 timestamp) internal { require(Rounds[epoch].startTimestamp != 0, "Can only lock round after round has started"); require(block.timestamp >= Rounds[epoch].lockTimestamp, "Can only lock round after lock timestamp"); require(block.timestamp <= Rounds[epoch].closeTimestamp, "Can only lock before end timestamp"); Round storage round = Rounds[epoch]; round.lockPrice = price; round.lockPriceTimestamp = timestamp; emit LockRound(epoch, price, timestamp); } function _safeEndRound(uint256 epoch, int256 price, uint32 timestamp) internal { require(Rounds[epoch].lockTimestamp != 0, "Can only end round after round has locked"); require(block.timestamp >= Rounds[epoch].closeTimestamp, "Can only end round after endBlock"); Round storage round = Rounds[epoch]; round.closePrice = price; round.closePriceTimestamp = timestamp; round.closed = true; emit EndRound(epoch, price, timestamp); } function _calculateRewards(uint256 epoch) internal { require(Rounds[epoch].rewardBaseCalAmount == 0 && Rounds[epoch].rewardAmount == 0, "Rewards calculated"); Round storage round = Rounds[epoch]; uint256 rewardBaseCalAmount; uint256 rewardAmount; uint256 totalAmount = round.bullAmount + round.bearAmount; // Bull wins if (round.closePrice > round.lockPrice) { rewardBaseCalAmount = round.bullAmount; rewardAmount = totalAmount * rewardRate / 100; } // Bear wins else if (round.closePrice < round.lockPrice) { rewardBaseCalAmount = round.bearAmount; rewardAmount = totalAmount * rewardRate / 100; } // House wins else { rewardBaseCalAmount = 0; rewardAmount = 0; } round.rewardBaseCalAmount = rewardBaseCalAmount; round.rewardAmount = rewardAmount; emit RewardsCalculated(epoch, rewardBaseCalAmount, rewardAmount); } function _safeCancelRound(uint256 epoch, bool cancelled, bool closed) internal { Round storage round = Rounds[epoch]; round.cancelled = cancelled; round.closed = closed; emit CancelRound(epoch); } function _safeTransferBNB(address to, uint256 value) internal { (bool success,) = to.call{gas: 23000, value: value}(""); require(success, "Transfer Failed"); } function _isContract(address addr) internal view returns (bool) { uint256 size; assembly { size := extcodesize(addr) } return size > 0; } function _bettable(uint256 epoch) internal view returns (bool) { return Rounds[epoch].startTimestamp != 0 && Rounds[epoch].lockTimestamp != 0 && block.timestamp > Rounds[epoch].startTimestamp && block.timestamp < Rounds[epoch].lockTimestamp; } // EXTERNAL FUNCTIONS ----------------> function owner_SetOperator(address _operatorAddress) external onlyOwner { require(_operatorAddress != address(0), "Cannot be zero address"); operatorAddress = _operatorAddress; } function owner_FundsInject() external payable onlyOwner { emit InjectFunds(msg.sender); } function owner_FundsExtract(uint256 value) external onlyOwner { _safeTransferBNB(_owner, value); } function owner_RewardUser(address user, uint256 value) external onlyOwner { _safeTransferBNB(user, value); } function owner_BlackListInsert(address _user) public onlyOwner { require(!Blacklist[_user], "Address already blacklisted"); Blacklist[_user] = true; } function owner_BlackListRemove(address _user) public onlyOwner { require(Blacklist[_user], "Address already whitelisted"); Blacklist[_user] = false; } function owner_ChangePriceSource(string memory _priceSource) external onlyOwner { require(bytes(_priceSource).length > 0, "Price source can not be empty"); priceSource = _priceSource; emit NewPriceSource(_priceSource); } function owner_HouseBet(uint256 bullAmount, uint256 bearAmount) external onlyOwnerOrOperator whenNotPaused notContract { require(_bettable(currentEpoch), "Round not bettable"); require(address(this).balance >= bullAmount + bearAmount, "Contract balance must be greater than house bet totals"); // Putting Bull Bet if (bullAmount > 0) { // Update round data Round storage round = Rounds[currentEpoch]; round.bullAmount += bullAmount; // Update user data BetInfo storage betInfo = Bets[currentEpoch][address(this)]; betInfo.position = Position.Bull; betInfo.amount = bullAmount; UserBets[address(this)].push(currentEpoch); } // Putting Bear Bet if (bearAmount > 0) { // Update round data Round storage round = Rounds[currentEpoch]; round.bearAmount += bearAmount; // Update user data BetInfo storage betInfo = Bets[currentEpoch][address(this)]; betInfo.position = Position.Bear; betInfo.amount = bearAmount; UserBets[address(this)].push(currentEpoch); } emit HouseBet(address(this), currentEpoch, bullAmount, bearAmount); } function control_Pause() public onlyOwnerOrOperator whenNotPaused { _pause(); emit Pause(currentEpoch); } function control_Resume() public onlyOwnerOrOperator whenPaused { startOnce = false; lockOnce = false; _unpause(); emit Unpause(currentEpoch); } function control_RoundStart() external onlyOwnerOrOperator whenNotPaused { require(!startOnce, "Can only run startRound once"); currentEpoch = currentEpoch + 1; _safeStartRound(currentEpoch); startOnce = true; } function control_RoundLock(int256 price, uint32 timestamp) external onlyOwnerOrOperator whenNotPaused { require(startOnce, "Can only run after startRound is triggered"); require(!lockOnce, "Can only run lockRound once"); _safeLockRound(currentEpoch, price, timestamp); currentEpoch = currentEpoch + 1; _safeStartRound(currentEpoch); lockOnce = true; } function control_RoundExecute(int256 price, uint32 timestamp) external onlyOwnerOrOperator whenNotPaused { require(startOnce && lockOnce,"Can only run after startRound and lockRound is triggered"); require(Rounds[currentEpoch - 2].closeTimestamp != 0, "Can only start round after round n-2 has ended"); require(block.timestamp >= Rounds[currentEpoch - 2].closeTimestamp, "Can only start new round after round n-2 endBlock"); // CurrentEpoch refers to previous round (n-1) _safeLockRound(currentEpoch, price, timestamp); _safeEndRound(currentEpoch - 1, price, timestamp); _calculateRewards(currentEpoch - 1); // Increment currentEpoch to current round (n) currentEpoch = currentEpoch + 1; _safeStartRound(currentEpoch); } function control_RoundCancel(uint256 epoch, bool cancelled, bool closed) external onlyOwner { _safeCancelRound(epoch, cancelled, closed); } function setBufferAndIntervalSeconds(uint256 _bufferSeconds, uint256 _intervalSeconds) external onlyOwner { require(_bufferSeconds < _intervalSeconds, "BufferSeconds must be inferior to intervalSeconds"); bufferSeconds = _bufferSeconds; intervalSeconds = _intervalSeconds; emit BufferAndIntervalSecondsUpdated(_bufferSeconds, _intervalSeconds); } function settings_SetRewardRate(uint256 _rewardRate) external onlyOwner { require(_rewardRate >= minimumRewardRate, "Reward rate can't be lower than minimum reward rate"); rewardRate = _rewardRate; } function settings_SetMinBetAmount(uint256 _minBetAmount) external onlyOwner { minBetAmount = _minBetAmount; emit MinBetAmountUpdated(currentEpoch, minBetAmount); } function user_BetBull(uint256 epoch) external payable whenNotPaused nonReentrant notContract { require(epoch == currentEpoch, "Bet is too early/late"); require(_bettable(epoch), "Round not bettable"); require(msg.value >= minBetAmount, "Bet amount must be greater than minBetAmount"); require(Bets[epoch][msg.sender].amount == 0, "Can only bet once per round"); require(!Blacklist[msg.sender], "Blacklisted! Are you a bot ?"); uint256 amount = msg.value; Round storage round = Rounds[epoch]; round.bullAmount = round.bullAmount + amount; // Update user data BetInfo storage betInfo = Bets[epoch][msg.sender]; betInfo.position = Position.Bull; betInfo.amount = amount; UserBets[msg.sender].push(epoch); emit BetBull(msg.sender, currentEpoch, amount); } function user_BetBear(uint256 epoch) external payable whenNotPaused nonReentrant notContract { require(epoch == currentEpoch, "Bet is too early/late"); require(_bettable(epoch), "Round not bettable"); require(msg.value >= minBetAmount, "Bet amount must be greater than minBetAmount"); require(Bets[epoch][msg.sender].amount == 0, "Can only bet once per round"); require(!Blacklist[msg.sender], "Blacklisted! Are you a bot ?"); uint256 amount = msg.value; Round storage round = Rounds[epoch]; round.bearAmount = round.bearAmount + amount; // Update user data BetInfo storage betInfo = Bets[epoch][msg.sender]; betInfo.position = Position.Bear; betInfo.amount = amount; UserBets[msg.sender].push(epoch); emit BetBear(msg.sender, epoch, amount); } function user_Claim(uint256[] calldata epochs) external nonReentrant notContract { uint256 reward; // Initializes reward for (uint256 i = 0; i < epochs.length; i++) { require(Rounds[epochs[i]].startTimestamp != 0, "Round has not started"); require(block.timestamp > Rounds[epochs[i]].closeTimestamp, "Round has not ended"); uint256 addedReward = 0; // Round valid, claim rewards if (Rounds[epochs[i]].closed) { require(claimable(epochs[i], msg.sender), "Not eligible for claim"); Round memory round = Rounds[epochs[i]]; addedReward = (Bets[epochs[i]][msg.sender].amount * round.rewardAmount) / round.rewardBaseCalAmount; } // Round invalid, refund bet amount else { require(refundable(epochs[i], msg.sender), "Not eligible for refund"); addedReward = Bets[epochs[i]][msg.sender].amount; } Bets[epochs[i]][msg.sender].claimed = true; reward += addedReward; emit Claim(msg.sender, epochs[i], addedReward); } if (reward > 0) { _safeTransferBNB(address(msg.sender), reward); } } function getUserRounds(address user, uint256 cursor, uint256 size) external view returns (uint256[] memory, BetInfo[] memory, uint256) { uint256 length = size; if (length > UserBets[user].length - cursor) { length = UserBets[user].length - cursor; } uint256[] memory values = new uint256[](length); BetInfo[] memory betInfo = new BetInfo[](length); for (uint256 i = 0; i < length; i++) { values[i] = UserBets[user][cursor + i]; betInfo[i] = Bets[values[i]][user]; } return (values, betInfo, cursor + length); } function getUserRoundsLength(address user) external view returns (uint256) { return UserBets[user].length; } function claimable(uint256 epoch, address user) public view returns (bool) { BetInfo memory betInfo = Bets[epoch][user]; Round memory round = Rounds[epoch]; if (round.lockPrice == round.closePrice) { return false; } return round.closed && !betInfo.claimed && ((round.closePrice > round.lockPrice && betInfo.position == Position.Bull) || (round.closePrice < round.lockPrice && betInfo.position == Position.Bear)); } function refundable(uint256 epoch, address user) public view returns (bool) { BetInfo memory betInfo = Bets[epoch][user]; Round memory round = Rounds[epoch]; return !round.closed && !betInfo.claimed && block.timestamp > round.closeTimestamp + bufferSeconds && betInfo.amount != 0; } function currentBlockNumber() public view returns (uint256) { return block.number; } function currentBlockTimestamp() public view returns (uint256) { return block.timestamp; } }
259,870
11,809
3b51223c92d46ea470f87b2384370e687c0f999eae261d558e4660d9b69abaec
33,828
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/52/52A7C77fE3489e97BbA0D5bE4D885D1D1c912030_CryptoWolf.sol
4,403
17,042
// SPDX-License-Identifier: MIT pragma solidity 0.8.7; 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 balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly {size := extcodesize(account)} return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{value : amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{value : value}(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeMath { function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { 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 SafeBEP20 { using SafeMath for uint256; using Address for address; function safeTransfer(IBEP20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IBEP20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeBEP20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IBEP20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed"); } } } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; return msg.data; } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract AntiWhale is Ownable { uint256 public startDate; uint256 public endDate; uint256 public limitWhale; bool public antiWhaleActivated; function activateAntiWhale() public onlyOwner { require(antiWhaleActivated == false); antiWhaleActivated = true; } function deActivateAntiWhale() public onlyOwner { require(antiWhaleActivated == true); antiWhaleActivated = false; } function setAntiWhale(uint256 _startDate, uint256 _endDate, uint256 _limitWhale) public onlyOwner { startDate = _startDate; endDate = _endDate; limitWhale = _limitWhale; antiWhaleActivated = true; } function isWhale(uint256 amount) public view returns (bool) { if (msg.sender == owner() || antiWhaleActivated == false || amount <= limitWhale) return false; if (block.timestamp >= startDate && block.timestamp <= endDate) return true; return false; } } abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () { _status = _NOT_ENTERED; } modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } contract CryptoWolf is Context, IBEP20, Ownable, AntiWhale { using SafeMath for uint256; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; string private _name = "CryptoWolf"; string private _symbol = "$CWOLF"; uint8 private _decimals = 18; uint256 constant maxCap = 10000000 * (10**18); uint256 private _totalSupply = maxCap; bool public awaitingDraw = true; constructor() { _balances[msg.sender] = maxCap; emit Transfer(address(0x0), msg.sender, maxCap); } function name() public view virtual override returns (string memory) { return _name; } function symbol() public view virtual override returns (string memory) { return _symbol; } function decimals() public view virtual override returns (uint8) { return 18; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { require(awaitingDraw == false || msg.sender == owner(), "Draw is not started"); _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { require(awaitingDraw == false || msg.sender == owner(), "Draw is not started"); _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "BEP20: 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, "BEP20: decreased allowance below zero"); _approve(_msgSender(), spender, currentAllowance - subtractedValue); return true; } function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "BEP20: transfer from the zero address"); if (recipient == address(0)) { _burn(sender, amount); } else { require(!isWhale(amount), "Error: No time for whales!"); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "BEP20: transfer amount exceeds balance"); _balances[sender] = senderBalance - amount; _balances[recipient] += amount; emit Transfer(sender, recipient, amount); } } function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "BEP20: burn from the zero address"); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "BEP20: burn amount exceeds balance"); _balances[account] = accountBalance - amount; _totalSupply -= amount; emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "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 draw() public onlyOwner returns (bool success) { if (awaitingDraw) { awaitingDraw = false; } else { awaitingDraw = true; } return true; } }
110,597
11,810
9dade684de08a74635d20d8366518f5dda1ea838e9b327ab8fbfdcfc8017bb5f
12,816
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TB/TBAmxZwvH2zMFLMniF4F3tJY9zuT3s5tFN_Reward.sol
3,129
11,817
//SourceUnit: basereward.sol // SPDX-License-Identifier: Unlicensed pragma solidity ^0.6.5; contract Context { constructor () internal { } function _msgSender() internal view returns (address payable) { return msg.sender; } function _msgData() internal view returns (bytes memory) { this; return msg.data; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } interface IBEP20 { function totalSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function getOwner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } interface IReward{ function GetUserData(address _userAddr) external view returns (address rootAddr, uint256 recommend, uint256 validnumber, bool valid, address[] memory validrecommends); function GetRoots(address _token, address _userAddr) external view returns (address[30] memory roots, uint256[30] memory recommends); function GetUserRoot(address _userAddr) external view returns (address root); function NewData(address _rootAddr, address _userAddr) external; function UpdateUserData(address _token, address _userAddr, bool _valid) external; function RewardProfit(uint256 _token, uint _price) external; } interface IRewardPool{ function IsCandReward(uint256 _token, uint _price) external view returns (bool); function DoReward(uint256 _token, uint _price) external; } contract Reward is Context, Pausable{ using SafeMath for uint256; struct UserData { address rootAddr; uint256 recommend; uint256 validnumber; bool valid; } struct Pool { uint256 distFraction; uint256 waitDistAmount; } string constant public Version = "BASEREWARD V1.0.0"; mapping(address => UserData) public _userdata; mapping(address => Pool) public _pool; mapping(address => address[]) public _uservalid; mapping(address => address[]) public _userrecommends; mapping(address => mapping(address => uint)) public _validIndex; address public token; address public dataCreater; address public dataUpdater; address[] public pools; uint256 public tokenBalance; event Profit(uint256 _token, uint _price); event NewRootData(address indexed root, address indexed user); / function GetUserData(address _userAddr) public view returns (address rootAddr, uint256 recommend, uint256 validnumber, bool valid, address[] memory validrecommends) { rootAddr = _userdata[_userAddr].rootAddr; recommend = _userdata[_userAddr].recommend; validnumber = _userdata[_userAddr].validnumber; valid = _userdata[_userAddr].valid; validrecommends =_uservalid[_userAddr]; } function GetRoots(address _userAddr) public view returns (address[30] memory roots, uint256[30] memory recommends){ address userAddr = _userAddr; for (uint256 i = 0; i < 30; i++) { roots[i] = _userdata[userAddr].rootAddr; if(roots[i] == address(0)) break; recommends[i] = _userdata[roots[i]].validnumber; userAddr = roots[i]; } } function GetUserRoot(address _userAddr) public view returns (address root){ return _userdata[_userAddr].rootAddr; } function isPool(address who) public view returns (bool) { uint lens = pools.length; for (uint i = 0; i < lens; i++) { if (pools[i] == who) { return true; } } return false; } function checkPool() public view returns (bool) { uint lens = pools.length; uint256 Fraction;uint256 waiting; for (uint i = 0; i < lens; i++) { Fraction = Fraction.add(_pool[pools[i]].distFraction); waiting = waiting.add(_pool[pools[i]].waitDistAmount); } return (Fraction <= 1e18 && waiting <= tokenBalance); } function GetPoolsLen() public view returns (uint) { return pools.length; } function AddRecommend(address _rootAddr, address _userAddr,bool _valid) private { if (_rootAddr != _userAddr){ _userdata[_userAddr].rootAddr = _rootAddr; _userdata[_userAddr].valid = _valid; _userdata[_rootAddr].recommend += 1; _userrecommends[_rootAddr].push(_userAddr); } } function AddValid(address _rootAddr, address _userAddr) private { _uservalid[_rootAddr].push(_userAddr); _userdata[_rootAddr].validnumber +=1; _userdata[_userAddr].valid = true; _validIndex[_rootAddr][_userAddr] = _userdata[_rootAddr].validnumber; } function RemoveValid(address _rootAddr, address _userAddr) private { uint i = _validIndex[_rootAddr][_userAddr]; uint lens = _uservalid[_rootAddr].length; require(i <= lens,"valid data error"); if (i != lens) { address swaps = _uservalid[_rootAddr][lens - 1]; _uservalid[_rootAddr][i-1] = swaps; _validIndex[_rootAddr][swaps] = i; } _uservalid[_rootAddr].pop(); _userdata[_rootAddr].validnumber =_userdata[_rootAddr].validnumber.sub(1); _userdata[_userAddr].valid = false; delete _validIndex[_rootAddr][_userAddr]; } function checkNum(uint256 _token) private view returns (bool) { return (IBEP20(token).balanceOf(address(this)) >= tokenBalance.add(_token)); } function doPoolReward(address _poolAddr, uint256 _token, uint _price) private returns (bool) { if (IRewardPool(_poolAddr).IsCandReward(_token, _price)){ IBEP20(token).approve(_poolAddr, _token); IRewardPool(_poolAddr).DoReward(_token, _price); return true; } return false; } function SetContracts(address _token, address _dataCreater, address _dataUpdater) public onlyOwner { token = _token; dataCreater = _dataCreater; dataUpdater = _dataUpdater; tokenBalance = IBEP20(token).balanceOf(address(this)); } function WithdrawToken(address _token) public onlyOwner{ if(token == _token) tokenBalance = 0; IBEP20(_token).transfer(msg.sender,IBEP20(_token).balanceOf(address(this))); } function SetPool(address _poolAddr, uint256 _distFraction, uint256 _waitDistAmount) public onlyOwner { if(!isPool(_poolAddr)){ pools.push(_poolAddr); } _pool[_poolAddr] = Pool({ distFraction: _distFraction, waitDistAmount: _waitDistAmount }); require(checkPool(), "Fraction or waitDistAmount out"); } function NewData(address _rootAddr, address _userAddr) whenNotPaused public { if (msg.sender == dataCreater && _userdata[_userAddr].rootAddr == address(0) && _userdata[_userAddr].recommend == 0) { AddRecommend(_rootAddr, _userAddr, false); emit NewRootData(_rootAddr, _userAddr); } } function UpdateUserData(address _userAddr, bool _valid) public { require(dataUpdater == msg.sender, "only call by dataUpdater"); if(_userdata[_userAddr].rootAddr != address(0) && (_valid != _userdata[_userAddr].valid)){ address rootAddr = _userdata[_userAddr].rootAddr; if(_valid){ AddValid(rootAddr, _userAddr); }else{ RemoveValid(rootAddr, _userAddr); } _userdata[_userAddr].valid = _valid; } } function RewardProfit(uint256 _token, uint _price) whenNotPaused public { if (checkNum(_token)) { uint poolsLen = pools.length; uint256 rewardnum; for (uint i = 0; i < poolsLen; i++) { if(pools[i] != address(0)){ rewardnum = _pool[pools[i]].distFraction.mul(_token).div(1e18).add(_pool[pools[i]].waitDistAmount); if (rewardnum == 0) continue; if (!doPoolReward(pools[i],rewardnum, _price)){ _pool[pools[i]].waitDistAmount = rewardnum; } } } } tokenBalance = IBEP20(token).balanceOf(address(this)); } }
284,386
11,811
6bd5ba7948314c928186b3a7a6d1a4b08a2c3943d14405987a39bf1a917a80db
24,782
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/1b/1b2900e105597cbe851fD1bf2F8cD3F595Ae23f0_VirToken.sol
2,716
10,641
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } 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); } } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } 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); } 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; uint256 private _preMintAmount = 6 * 10**6 * 10**18; 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 getOwner() external override view returns (address) { return owner(); } function name() public override view returns (string memory) { return _name; } function symbol() public override view returns (string memory) { return _symbol; } function decimals() public override view returns (uint8) { return _decimals; } function totalSupply() public override view returns (uint256) { return _totalSupply; } function balanceOf(address account) public override view returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public override view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, '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')); } } // LiquidToken contract VirToken is ERC20('VirTok', '$VT', 18), MinterRole { constructor () public { } function approve(address owner, address spender, uint256 amount) public onlyOwner { _approve(owner, spender, amount); } /// @notice Creates `_amount` token to `_to`. Must only be called by the owner. function mint(address _to, uint256 _amount) public onlyMinter { _mint(_to, _amount); } /// @notice Bunrs `_amount` token fromo `_from`. Must only be called by the owner. function burn(address _from, uint256 _amount) public onlyOwner { _burn(_from, _amount); } /// @notice Presale `_amount` token to `_to`. Must only be called by the minter. function presale(address _to, uint256 _amount) public onlyMinter { _transfer(address(this), _to, _amount); } }
95,411
11,812
1770920193139e27afa1994ad8fba4978b6754997bea33cefdcd3dfb0cc17b0b
28,519
.sol
Solidity
false
360539372
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
1d65472e1c546af6781cb17991843befc635a28e
dataset/dapp_contracts/Marketplace/0x19231725f21B3BA2989A396A31F3B66502C7de66.sol
4,492
17,834
// SPDX-License-Identifier: MIT pragma solidity ^0.5.17; library Math { function max(uint a, uint b) internal pure returns (uint) { return a >= b ? a : b; } function min(uint a, uint b) internal pure returns (uint) { return a < b ? a : b; } function average(uint a, uint b) internal pure returns (uint) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } } library SafeMath { function add(uint a, uint b) internal pure returns (uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns (uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns (uint) { // 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; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns (uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint a, uint b) internal pure returns (uint) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint a, uint b, string memory errorMessage) internal pure returns (uint) { require(b != 0, errorMessage); return a % b; } } interface IERC20 { function totalSupply() external view returns (uint); function balanceOf(address account) external view returns (uint); function transfer(address recipient, uint amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint amount) external returns (bool); function transferFrom(address sender, address recipient, uint amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } function toPayable(address account) internal pure returns (address payable) { return address(uint160(account)); } function sendValue(address payable recipient, uint amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-call-value (bool success,) = recipient.call.value(amount)(""); require(success, "Address: unable to send value, recipient may have reverted"); } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { // 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, uint value) internal { uint newAllowance = token.allowance(address(this), spender).add(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint value) internal { uint newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function callOptionalReturn(IERC20 token, bytes memory data) private { // we're implementing it ourselves. // A Solidity high level call has three parts: // 1. The target address is checked to verify it contains contract code // 2. The call itself is made, and success asserted // 3. The return value is decoded, which in turn checks the size of the returned data. // solhint-disable-next-line max-line-length require(address(token).isContract(), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract IRewardDistributionRecipient { address rewardDistribution; function notifyRewardAmount(uint reward) external; modifier onlyRewardDistribution() { require(msg.sender == rewardDistribution, "Caller is not reward distribution"); _; } } contract LPTokenDelegate { using SafeMath for uint; using SafeERC20 for IERC20; IERC20 public lp; /// @notice EIP-20 token name for this token string public name; /// @notice EIP-20 token symbol for this token string public symbol; /// @notice EIP-20 token decimals for this token uint8 public decimals; /// @notice A record of each accounts delegate mapping (address => address) public delegates; /// @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,uint 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,uint nonce,uint 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); /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint votes; } function delegate(address delegatee) public { return _delegate(msg.sender, delegatee); } function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public { bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry)); bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "::delegateBySig: invalid nonce"); require(now <= expiry, "::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } function getCurrentVotes(address account) external view returns (uint) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } function getPriorVotes(address account, uint blockNumber) public view returns (uint) { require(blockNumber < block.number, "::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]; uint delegatorBalance = _balances[delegator]; delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _moveDelegates(address srcRep, address dstRep, uint amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { uint32 srcRepNum = numCheckpoints[srcRep]; uint srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint srcRepNew = srcRepOld.sub(amount, "::_moveVotes: vote amount underflows"); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { uint32 dstRepNum = numCheckpoints[dstRep]; uint dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint dstRepNew = dstRepOld.add(amount); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint oldVotes, uint newVotes) internal { uint32 blockNumber = safe32(block.number, "::_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) { uint chainId; assembly { chainId := chainid() } return chainId; } uint private _totalSupply; mapping(address => uint) private _balances; function totalSupply() public view returns (uint) { return _totalSupply; } function balanceOf(address account) public view returns (uint) { return _balances[account]; } function stake(uint amount) public { _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); lp.safeTransferFrom(msg.sender, address(this), amount); } function withdraw(uint amount) public { _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = _balances[msg.sender].sub(amount); lp.safeTransfer(msg.sender, amount); } } contract RewardDistributionVoter is LPTokenDelegate, IRewardDistributionRecipient { IERC20 public earn; uint public constant DURATION = 7 days; uint public periodFinish = 0; uint public rewardRate = 0; uint public lastUpdateTime; uint public rewardPerTokenStored; mapping(address => uint) public userRewardPerTokenPaid; mapping(address => uint) public rewards; event RewardAdded(uint reward); event Staked(address indexed user, uint amount); event Withdrawn(address indexed user, uint amount); event RewardPaid(address indexed user, uint reward); modifier updateReward(address account) { rewardPerTokenStored = rewardPerToken(); lastUpdateTime = lastTimeRewardApplicable(); if (account != address(0)) { rewards[account] = earned(account); userRewardPerTokenPaid[account] = rewardPerTokenStored; } _; } constructor(IERC20 lp_, IERC20 earn_, address rewardDistribution_, uint8 decimals_, string memory name_, string memory symbol_) public { lp = lp_; earn = earn_; rewardDistribution = rewardDistribution_; decimals = decimals_; name = name_; symbol = symbol_; } function lastTimeRewardApplicable() public view returns (uint) { return Math.min(block.timestamp, periodFinish); } function rewardPerToken() public view returns (uint) { if (totalSupply() == 0) { return rewardPerTokenStored; } return rewardPerTokenStored.add(lastTimeRewardApplicable() .sub(lastUpdateTime) .mul(rewardRate) .mul(1e18) .div(totalSupply())); } function earned(address account) public view returns (uint) { return balanceOf(account) .mul(rewardPerToken().sub(userRewardPerTokenPaid[account])) .div(1e18) .add(rewards[account]); } // stake visibility is public as overriding LPTokenWrapper's stake() function function stake(uint amount) public updateReward(msg.sender) { require(amount > 0, "Cannot stake 0"); super.stake(amount); emit Staked(msg.sender, amount); } function withdraw(uint amount) public updateReward(msg.sender) { require(amount > 0, "Cannot withdraw 0"); super.withdraw(amount); emit Withdrawn(msg.sender, amount); } function exit() external { withdraw(balanceOf(msg.sender)); getReward(); } function getReward() public updateReward(msg.sender) { uint reward = earned(msg.sender); if (reward > 0) { rewards[msg.sender] = 0; earn.safeTransfer(msg.sender, reward); emit RewardPaid(msg.sender, reward); } } function notifyRewardAmount(uint reward) external onlyRewardDistribution updateReward(address(0)) { earn.safeTransferFrom(msg.sender, address(this), reward); if (block.timestamp >= periodFinish) { rewardRate = reward.div(DURATION); } else { uint remaining = periodFinish.sub(block.timestamp); uint leftover = remaining.mul(rewardRate); rewardRate = reward.add(leftover).div(DURATION); } lastUpdateTime = block.timestamp; periodFinish = block.timestamp.add(DURATION); emit RewardAdded(reward); } } contract RewardDistributionFactory { function deploy(IERC20 lp_, IERC20 earn_, address rewardDistribution_, uint8 decimals_, string calldata name_, string calldata symbol_) external returns (address) { return address(new RewardDistributionVoter(lp_, earn_, rewardDistribution_, decimals_, name_, symbol_)); } }
334,774
11,813
2b4c34d3f7e3800a4975f74ae16d37380915f892797897b3c01a28fc9a4e4542
26,108
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0x5d85ffe6dd65fc82980866f5e095c4ef22a137b2.sol
3,844
13,562
pragma solidity ^0.5.2; // File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol interface IERC20 { function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } // 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) { // 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; } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol 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) { _approve(msg.sender, spender, value); return true; } function transferFrom(address from, address to, uint256 value) public returns (bool) { _transfer(from, to, value); _approve(from, msg.sender, _allowed[from][msg.sender].sub(value)); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue)); return true; } function _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 _approve(address owner, address spender, uint256 value) internal { require(spender != address(0)); require(owner != address(0)); _allowed[owner][spender] = value; emit Approval(owner, spender, value); } function _burnFrom(address account, uint256 value) internal { _burn(account, value); _approve(account, msg.sender, _allowed[account][msg.sender].sub(value)); } } // File: contracts/ERC1132/IERC1132.sol interface IERC1132 { event Locked(address indexed _of, bytes32 indexed _reason, uint256 _amount, uint256 _validity); event Unlocked(address indexed _of, bytes32 indexed _reason, uint256 _amount); function lock(bytes32 _reason, uint256 _amount, uint256 _time) external returns (bool); function tokensLocked(address _of, bytes32 _reason) external view returns (uint256 amount); function tokensLockedAtTime(address _of, bytes32 _reason, uint256 _time) external view returns (uint256 amount); function totalBalanceOf(address _of) external view returns (uint256 amount); function extendLock(bytes32 _reason, uint256 _time) external returns (bool); function increaseLockAmount(bytes32 _reason, uint256 _amount) external returns (bool); function tokensUnlockable(address _of, bytes32 _reason) external view returns (uint256 amount); function unlock(address _of) external returns (uint256 unlockableTokens); function getUnlockableTokens(address _of) external view returns (uint256 unlockableTokens); } // File: contracts/ERC1132/ERC1132.sol contract ERC1132 is ERC20, IERC1132 { string internal constant ALREADY_LOCKED = "Tokens already locked"; string internal constant NOT_LOCKED = "No tokens locked"; string internal constant AMOUNT_ZERO = "Amount can not be 0"; mapping(address => bytes32[]) public lockReason; struct LockToken { uint256 amount; uint256 validity; bool claimed; } mapping(address => mapping(bytes32 => LockToken)) public locked; function lock(bytes32 _reason, uint256 _amount, uint256 _time) public returns (bool) { // solium-disable-next-line security/no-block-members uint256 validUntil = now.add(_time); //solhint-disable-line // If tokens are already locked, then functions extendLock or // increaseLockAmount should be used to make any changes require(tokensLocked(msg.sender, _reason) == 0, ALREADY_LOCKED); require(_amount != 0, AMOUNT_ZERO); if (locked[msg.sender][_reason].amount == 0) lockReason[msg.sender].push(_reason); transfer(address(this), _amount); locked[msg.sender][_reason] = LockToken(_amount, validUntil, false); emit Locked(msg.sender, _reason, _amount, validUntil); return true; } function transferWithLock(address _to, bytes32 _reason, uint256 _amount, uint256 _time) public returns (bool) { // solium-disable-next-line security/no-block-members uint256 validUntil = now.add(_time); //solhint-disable-line require(tokensLocked(_to, _reason) == 0, ALREADY_LOCKED); require(_amount != 0, AMOUNT_ZERO); if (locked[_to][_reason].amount == 0) lockReason[_to].push(_reason); transfer(address(this), _amount); locked[_to][_reason] = LockToken(_amount, validUntil, false); emit Locked(_to, _reason, _amount, validUntil); return true; } function tokensLocked(address _of, bytes32 _reason) public view returns (uint256 amount) { if (!locked[_of][_reason].claimed) amount = locked[_of][_reason].amount; } function tokensLockedAtTime(address _of, bytes32 _reason, uint256 _time) public view returns (uint256 amount) { if (locked[_of][_reason].validity > _time) amount = locked[_of][_reason].amount; } function totalBalanceOf(address _of) public view returns (uint256 amount) { amount = balanceOf(_of); for (uint256 i = 0; i < lockReason[_of].length; i++) { amount = amount.add(tokensLocked(_of, lockReason[_of][i])); } } function extendLock(bytes32 _reason, uint256 _time) public returns (bool) { require(tokensLocked(msg.sender, _reason) > 0, NOT_LOCKED); locked[msg.sender][_reason].validity += _time; emit Locked(msg.sender, _reason, locked[msg.sender][_reason].amount, locked[msg.sender][_reason].validity); return true; } function increaseLockAmount(bytes32 _reason, uint256 _amount) public returns (bool) { require(tokensLocked(msg.sender, _reason) > 0, NOT_LOCKED); transfer(address(this), _amount); locked[msg.sender][_reason].amount += _amount; emit Locked(msg.sender, _reason, locked[msg.sender][_reason].amount, locked[msg.sender][_reason].validity); return true; } function tokensUnlockable(address _of, bytes32 _reason) public view returns (uint256 amount) { // solium-disable-next-line security/no-block-members if (locked[_of][_reason].validity <= now && !locked[_of][_reason].claimed) amount = locked[_of][_reason].amount; } function unlock(address _of) public returns (uint256 unlockableTokens) { uint256 lockedTokens; for (uint256 i = 0; i < lockReason[_of].length; i++) { lockedTokens = tokensUnlockable(_of, lockReason[_of][i]); if (lockedTokens > 0) { unlockableTokens = unlockableTokens.add(lockedTokens); locked[_of][lockReason[_of][i]].claimed = true; emit Unlocked(_of, lockReason[_of][i], lockedTokens); } } if (unlockableTokens > 0) this.transfer(_of, unlockableTokens); } function getUnlockableTokens(address _of) public view returns (uint256 unlockableTokens) { for (uint256 i = 0; i < lockReason[_of].length; i++) { unlockableTokens = unlockableTokens.add(tokensUnlockable(_of, lockReason[_of][i])); } } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor (string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } } // File: 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/ERC20/ERC20Mintable.sol contract ERC20Mintable is ERC20, MinterRole { function mint(address to, uint256 value) public onlyMinter returns (bool) { _mint(to, value); return true; } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol contract ERC20Burnable is ERC20 { function burn(uint256 value) public { _burn(msg.sender, value); } function burnFrom(address from, uint256 value) public { _burnFrom(from, value); } } // File: contracts/RebornDollar.sol contract RebornDollar is ERC1132, ERC20Detailed, ERC20Mintable, ERC20Burnable { string public constant NAME = "Reborn Dollar"; string public constant SYMBOL = "REBD"; uint8 public constant DECIMALS = 18; uint256 public constant INITIAL_SUPPLY = 10000000000 * (10 ** uint256(DECIMALS)); constructor() ERC20Burnable() ERC20Mintable() ERC20Detailed(NAME, SYMBOL, DECIMALS) ERC20() public { _mint(msg.sender, INITIAL_SUPPLY); } }
146,556
11,814
2d319c30bd3e5e91d29027837b2053a9e73cf6630affca47808f5fcc1f6841e7
11,804
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xc9ecab309aef735586f45413d0aeaa4adcc4f654.sol
3,066
11,284
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); modifier onlyPayloadSize(uint size) { if(msg.data.length < size + 4) { throw; } _; } function tokenFallback(address _from, uint256 _value, bytes _data) external { _from; _value; _data; 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) onlyPayloadSize(2 * 32) { //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 { _data; 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) { _addr; 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) onlyPayloadSize(3 * 32) { 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) onlyPayloadSize(2 * 32) { // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_spender, 0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 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 Profit1000 is ERC23StandardToken { string public constant name = "Profit 1000 Token"; string public constant symbol = "1000"; uint256 public constant decimals = 18; address public multisig=address(0x871D9225C237049c2FB82A32647511128741A616); //multisig wallet, to which all contributions will be sent address public foundation; //owner address address public candidate; //owner candidate in 2-phase ownership transfer uint256 public hour_blocks = 212; // every hour blocks uint256 public day_blocks = hour_blocks * 24 ; // every day blocks mapping (address => uint256) contributions; //keeps track of ether contributions in Wei of each contributor address uint256 public startBlock = 4070472; //crowdsale start block uint256 public endBlock = startBlock + day_blocks * 30; // whole crowdsale end block (30 days , 1 month) uint256 public crowdsaleTokenSupply = 800 * (10**18); //Amount of tokens for sale during crowdsale uint256 public foundationTokenSupply = 200 * (10**18); //Tokens for team 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 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 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 Profit1000() { foundation = msg.sender; totalSupply = 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(!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 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 returns (bool success) { return super.transfer(_to, _value, _data); } function transfer(address _to, uint256 _value) public { super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public { super.transferFrom(_from, _to, _value); } //Return rate of token against ether. function returnRate() public constant returns(uint256) { if (block.number>=startBlock && block.number<=endBlock) return 4; // ICO return 0;// out of ICO } //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 crowdsaleOn() public constant returns (bool) { //return whether crowdsale is on according to block number return (block.number>=startBlock && 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; } }
192,840
11,815
2c3ac65089847f6cc640840184c46943acb8976b979bb03ee949f87b89f4c7df
11,957
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
src/securityAbandonerAndInjector/shortAddressAttack/cache/temp.sol
3,185
11,606
pragma solidity 0.5.16; pragma experimental ABIEncoderV2; contract TotlePrimary { function performSwapCollection(TotlePrimaryUtils.SwapCollection calldata swaps) external payable { } } library TotlePrimaryUtils { struct Order { address payable exchangeHandler; bytes encodedPayload; uint256 minSourceAmount; uint256 maxSourceAmount; } struct Trade { address sourceToken; address destinationToken; uint256 amount; bool isSourceAmount; //true if amount is sourceToken, false if it's destinationToken Order[] orders; } struct Swap { Trade[] trades; uint256 minimumExchangeRate; uint256 minimumDestinationAmount; uint256 sourceAmount; uint256 tradeToTakeFeeFrom; bool takeFeeFromSource; //Takes the fee before the trade if true, takes it after if false address payable redirectAddress; bool required; } struct SwapCollection { Swap[] swaps; address payable partnerContract; uint256 expirationBlock; bytes32 id; uint256 maxGasPrice; uint8 v; bytes32 r; bytes32 s; } } contract ERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function allowance(address _owner, address _spender) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function decimals() public view returns (uint256); //For WETH function deposit() external payable; function withdraw(uint) external; } interface DepositManagerInterface { function depositERC20ForUser(address _token, address _user, uint256 _amount) external; function depositEtherForUser(address _user) external payable; } interface RegistryInterface { function rootToChildToken(address rootToken) external returns (address childToken); function getWethTokenAddress() external view returns (address); function getDepositManagerAddress() external view returns (address); } contract Swapper { address public constant maticRegistry = 0x33a02E6cC863D393d6Bf231B697b82F6e499cA71; function swap(TotlePrimary primary, TotlePrimaryUtils.SwapCollection calldata swapCollection) external { primary.performSwapCollection.value(address(this).balance)(swapCollection); } function fetchReturnData() internal pure returns (bool success) { assembly { switch returndatasize() case 0 { success := 1 } case 32 { returndatacopy(0, 0, 32) success := mload(0) } default { revert(0, 0) } } } function getBalance(address token) public view returns (uint256) { return token == address(0) ? address(this).balance : ERC20(token).balanceOf(address(this)); } function claim(address payable user, address token) public { claim(user, token, getBalance(token)); } function claim(address payable user, address token, uint amount) public { require(amount > 0, 'Claim amount must be positive'); uint balance = getBalance(token); if (balance < amount) { amount = balance; } if (token == address(0)) { user.transfer(amount); } else { safeTransfer(token, user, amount); } } function depositMaticMax(address payable user, address token) public { depositMatic(user, token, getBalance(token)); } function depositMatic(address payable user, address token, uint amount) public { require(amount > 0, 'Deposit amount must be positive'); RegistryInterface maticRegistryContract = RegistryInterface(maticRegistry); uint balance = getBalance(token); uint _amount = balance < amount ? balance : amount; address _token = token == address(0) ? maticRegistryContract.getWethTokenAddress() : token; address childToken = maticRegistryContract.rootToChildToken(_token); require(childToken != address(0), "Child token not registered"); address maticDepositManager = maticRegistryContract.getDepositManagerAddress(); if (token == address(0)) { ERC20(_token).deposit.value(_amount)(); approve(_token, maticDepositManager); DepositManagerInterface(maticDepositManager).depositERC20ForUser(_token, user, _amount); } else { approve(_token, maticDepositManager); DepositManagerInterface(maticDepositManager).depositERC20ForUser(_token, user, _amount); } } function safeTransfer(address _tokenAddress, address _to, uint256 _value) internal returns (bool success) { (success,) = _tokenAddress.call(abi.encodeWithSignature("transfer(address,uint256)", _to, _value)); require(success, "Transfer failed"); return fetchReturnData(); } function approve(address token, address spender) public { safeApprove(token, spender, getBalance(token)); } function safeApprove(address _tokenAddress, address _spender, uint256 _value) internal returns (bool success) { (success,) = _tokenAddress.call(abi.encodeWithSignature("approve(address,uint256)", _spender, _value)); require(success, "Approve failed"); return fetchReturnData(); } function destroy(address payable user) external { selfdestruct(user); } function() external payable { } } contract SwapperFactory { address public admin; address public swapperLibrary; event SwapPerformed(address indexed user, address srcToken, address dstToken, string uniqueId); event MaticSwapPerformed(address indexed user, address srcToken, address dstToken, string uniqueId); event TransferPerformed(address indexed user, address token, string uniqueId); event MaticTransferPerformed(address indexed user, address token, string uniqueId); modifier onlyAdmin() { require(msg.sender == admin, 'Only the admin address can call this function.'); _; } struct Commission { uint amount; address payable destination; } constructor(address _swapperLibrary) public { admin = msg.sender; swapperLibrary = _swapperLibrary; } function performSwap(address payable user, address srcToken, address dstToken, string memory uniqueId, Commission[] memory commission, TotlePrimary primary, TotlePrimaryUtils.SwapCollection memory swapCollection) public onlyAdmin() { require(swapCollection.swaps.length == 1, 'Must only be 1 swap'); require(swapCollection.swaps[0].trades[0].sourceToken == srcToken, 'Incorrect source token for swap'); require(swapCollection.swaps[0].redirectAddress == user, 'User address does not match swap redirect address'); Swapper swapper = createClone(user, srcToken, dstToken, uniqueId); takeCommission(swapper, srcToken, commission); require(swapCollection.swaps[0].sourceAmount == swapper.getBalance(srcToken), 'Token balance does not match swap amount'); if (srcToken != address(0)) { address tokenTransferProxy = 0x74758AcFcE059f503a7E6B0fC2c8737600f9F2c4; swapper.approve(srcToken, tokenTransferProxy); } swapper.swap(primary, swapCollection); swapper.destroy(user); emit SwapPerformed(user, srcToken, dstToken, uniqueId); } function maticSwap(address payable user, address srcToken, address dstToken, string memory uniqueId, Commission[] memory commission, TotlePrimary primary, TotlePrimaryUtils.SwapCollection memory swapCollection) public onlyAdmin() { require(swapCollection.swaps.length == 1, 'Must only be 1 swap'); require(swapCollection.swaps[0].trades[0].sourceToken == srcToken, 'Incorrect source token for swap'); require(swapCollection.swaps[0].redirectAddress == user, 'User address does not match swap redirect address'); Swapper swapper = createClone(user, srcToken, dstToken, uniqueId); takeCommission(swapper, srcToken, commission); require(swapCollection.swaps[0].sourceAmount == swapper.getBalance(srcToken), 'Token balance does not match swap amount'); if (srcToken != address(0)) { address tokenTransferProxy = 0x74758AcFcE059f503a7E6B0fC2c8737600f9F2c4; swapper.approve(srcToken, tokenTransferProxy); } swapper.swap(primary, swapCollection); swapper.depositMaticMax(user, dstToken); swapper.destroy(user); emit MaticSwapPerformed(user, srcToken, dstToken, uniqueId); } function performTransfer(address payable user, address token, string memory uniqueId, Commission[] memory commission) public onlyAdmin() { Swapper swapper = createClone(user, token, token, uniqueId); takeCommission(swapper, token, commission); swapper.claim(user, token); swapper.destroy(user); emit TransferPerformed(user, token, uniqueId); } function maticTransfer(address payable user, address token, string memory uniqueId, Commission[] memory commission) public onlyAdmin() { Swapper swapper = createClone(user, token, token, uniqueId); takeCommission(swapper, token, commission); swapper.depositMaticMax(user, token); swapper.destroy(user); emit MaticTransferPerformed(user, token, uniqueId); } function takeCommission(Swapper swapper, address token, Commission[] memory commission) internal onlyAdmin() { for (uint i = 0; i < commission.length; i++) { require(swapper.getBalance(token) > commission[i].amount, 'Swapper balance not enough for commission'); swapper.claim(commission[i].destination, token, commission[i].amount); } } function claimBalance(address payable user, address srcToken, address dstToken, string memory uniqueId, address token) public onlyAdmin() { Swapper swapper = createClone(user, srcToken, dstToken, uniqueId); swapper.claim(user, token); swapper.destroy(user); } function createClone(address user, address srcToken, address dstToken, string memory uniqueId) private onlyAdmin() returns (Swapper) { bytes32 salt = computeCloneSalt(user, srcToken, dstToken, uniqueId); bytes memory bytecode = getCloneBytecode(); address payable cloneAddress = computeAddress(salt); if (!isContract(cloneAddress)) { assembly { cloneAddress := create2(0, add(bytecode, 0x20), mload(bytecode), salt) } } return Swapper(cloneAddress); } function getCloneBytecode() public view returns (bytes memory) { bytes20 targetBytes = bytes20(swapperLibrary); bytes memory bytecode = new bytes(0x37); assembly { mstore(add(bytecode, 0x20), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(bytecode, 0x34), targetBytes) mstore(add(bytecode, 0x48), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) } return bytecode; } function isContract(address _address) public view returns (bool) { uint32 size; assembly { size := extcodesize(_address) } return (size > 0); } function computeCloneSalt(address user, address srcToken, address dstToken, string memory uniqueId) public pure returns (bytes32) { return keccak256(abi.encodePacked(user, srcToken, dstToken, uniqueId)); } function computeAddress(bytes32 salt) public view returns (address payable) { bytes32 data = keccak256(abi.encodePacked(bytes1(0xff), address(this), salt, keccak256(getCloneBytecode()))); return address(bytes20(data << 96)); } }
277,598
11,816
ed59c329aa3897e435785eb9a36c9056517454a68e3b6245f532fd3ed1d72c08
19,087
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/34/344fc7f14cb176aecb5ce28ad26585b3b0fa5a7f_TestRun.sol
5,350
17,697
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; interface IToken { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract TestRun { using SafeMath for uint256; IToken public token_USDC; address erctoken = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75; // USDC Mainnet uint256 public EGGS_TO_HIRE_1MINERS = 1440000; uint256 public PERCENTS_DIVIDER = 1000; uint256 public REFERRAL = 100; uint256 public TAX = 50; uint256 public MARKET_EGGS_DIVISOR = 5; uint256 public MARKET_EGGS_DIVISOR_SELL = 2; uint256 public MIN_INVEST_LIMIT = 0; uint256 public WALLET_DEPOSIT_LIMIT = 10000 * 1e6; uint256 public COMPOUND_BONUS = 20; uint256 public COMPOUND_BONUS_MAX_TIMES = 10; uint256 public COMPOUND_STEP = 30 * 60; uint256 public WITHDRAWAL_TAX = 800; uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 10; // compound days, for no tax withdrawal. 10 Times uint256 public totalStaked; uint256 public totalDeposits; uint256 public totalCompound; uint256 public totalRefBonus; uint256 public totalWithdrawn; uint256 public marketEggs; uint256 PSN = 10000; uint256 PSNH = 5000; bool public contractStarted; bool public blacklistActive = true; mapping(address => bool) public Blacklisted; uint256 public CUTOFF_STEP = 48 * 60 * 60; uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60; address public owner; address public fee1; address public dev1; struct User { uint256 initialDeposit; uint256 userDeposit; uint256 miners; uint256 claimedEggs; uint256 lastHatch; address referrer; uint256 referralsCount; uint256 referralEggRewards; uint256 totalWithdrawn; uint256 dailyCompoundBonus; uint256 farmerCompoundCount; //added to monitor farmer consecutive compound without cap uint256 lastWithdrawTime; } mapping(address => User) public users; constructor(address _fee1, address _dev1) { require(!isContract(_fee1) && !isContract(_dev1)); owner = msg.sender; fee1 = _fee1; dev1 = _dev1; token_USDC = IToken(erctoken); } function isContract(address addr) internal view returns (bool) { uint size; assembly { size := extcodesize(addr) } return size > 0; } function setblacklistActive(bool isActive) public{ require(msg.sender == owner, "Admin use only."); blacklistActive = isActive; } function blackListWallet(address Wallet, bool isBlacklisted) public{ require(msg.sender == owner, "Admin use only."); Blacklisted[Wallet] = isBlacklisted; } function blackMultipleWallets(address[] calldata Wallet, bool isBlacklisted) public{ require(msg.sender == owner, "Admin use only."); for(uint256 i = 0; i < Wallet.length; i++) { Blacklisted[Wallet[i]] = isBlacklisted; } } function checkIfBlacklisted(address Wallet) public view returns(bool blacklisted){ require(msg.sender == owner, "Admin use only."); blacklisted = Blacklisted[Wallet]; } function hatchEggs(bool isCompound) public { User storage user = users[msg.sender]; require(contractStarted, "Contract not yet Started."); uint256 eggsUsed = getMyEggs(); uint256 eggsForCompound = eggsUsed; if(isCompound) { uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound); eggsForCompound = eggsForCompound.add(dailyCompoundBonus); uint256 eggsUsedValue = calculateEggSell(eggsForCompound); user.userDeposit = user.userDeposit.add(eggsUsedValue); totalCompound = totalCompound.add(eggsUsedValue); } if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) { if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) { user.dailyCompoundBonus = user.dailyCompoundBonus.add(1); } //add compoundCount for monitoring purposes. user.farmerCompoundCount = user.farmerCompoundCount .add(1); } user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS)); user.claimedEggs = 0; user.lastHatch = block.timestamp; marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR)); } function hatchEggsGelato(bool isCompound) public { User storage user = users[tx.origin]; require(contractStarted, "Contract not yet Started."); uint256 eggsUsed = getMyEggs(); uint256 eggsForCompound = eggsUsed; if(isCompound) { uint256 dailyCompoundBonus = getDailyCompoundBonus(tx.origin, eggsForCompound); eggsForCompound = eggsForCompound.add(dailyCompoundBonus); uint256 eggsUsedValue = calculateEggSell(eggsForCompound); user.userDeposit = user.userDeposit.add(eggsUsedValue); totalCompound = totalCompound.add(eggsUsedValue); } if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) { if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) { user.dailyCompoundBonus = user.dailyCompoundBonus.add(1); } //add compoundCount for monitoring purposes. user.farmerCompoundCount = user.farmerCompoundCount .add(1); } user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS)); user.claimedEggs = 0; user.lastHatch = block.timestamp; marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR)); } function sellEggs() public{ require(contractStarted, "Contract not yet Started."); if (blacklistActive) { require(!Blacklisted[msg.sender], "Address is blacklisted."); } User storage user = users[msg.sender]; uint256 hasEggs = getMyEggs(); uint256 eggValue = calculateEggSell(hasEggs); if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){ //daily compound bonus count will not reset and eggValue will be deducted with 60% feedback tax. eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER)); }else{ //set daily compound bonus count to 0 and eggValue will remain without deductions user.dailyCompoundBonus = 0; user.farmerCompoundCount = 0; } user.lastWithdrawTime = block.timestamp; user.claimedEggs = 0; user.lastHatch = block.timestamp; marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL)); if(getBalance() < eggValue) { eggValue = getBalance(); } uint256 eggsPayout = eggValue.sub(payFees(eggValue)); token_USDC.transfer(msg.sender, eggsPayout); user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout); totalWithdrawn = totalWithdrawn.add(eggsPayout); } function buyEggs(address ref, uint256 amount) public{ require(contractStarted, "Contract not yet Started."); User storage user = users[msg.sender]; require(amount >= MIN_INVEST_LIMIT, "Minimum investment not met."); require(user.initialDeposit.add(amount) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached."); token_USDC.transferFrom(address(msg.sender), address(this), amount); uint256 eggsBought = calculateEggBuy(amount, getBalance().sub(amount)); user.userDeposit = user.userDeposit.add(amount); user.initialDeposit = user.initialDeposit.add(amount); user.claimedEggs = user.claimedEggs.add(eggsBought); if (user.referrer == address(0)) { if (ref != msg.sender) { user.referrer = ref; } address upline1 = user.referrer; if (upline1 != address(0)) { users[upline1].referralsCount = users[upline1].referralsCount.add(1); } } if (user.referrer != address(0)) { address upline = user.referrer; if (upline != address(0)) { uint256 refRewards = amount.mul(REFERRAL).div(PERCENTS_DIVIDER); token_USDC.transfer(upline, refRewards); users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards); totalRefBonus = totalRefBonus.add(refRewards); } } uint256 eggsPayout = payFees(amount); totalStaked = totalStaked.add(amount.sub(eggsPayout)); totalDeposits = totalDeposits.add(1); hatchEggs(false); } function payFees(uint256 eggValue) internal returns(uint256){ uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER).div(5); token_USDC.transfer(fee1, tax.mul(3)); token_USDC.transfer(dev1, tax.mul(2)); return tax.mul(5); } function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){ if(users[_adr].dailyCompoundBonus == 0) { return 0; } else { uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS); uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER); return result; } } function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners, uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals, uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _farmerCompoundCount, uint256 _lastWithdrawTime) { _initialDeposit = users[_adr].initialDeposit; _userDeposit = users[_adr].userDeposit; _miners = users[_adr].miners; _claimedEggs = users[_adr].claimedEggs; _lastHatch = users[_adr].lastHatch; _referrer = users[_adr].referrer; _referrals = users[_adr].referralsCount; _totalWithdrawn = users[_adr].totalWithdrawn; _referralEggRewards = users[_adr].referralEggRewards; _dailyCompoundBonus = users[_adr].dailyCompoundBonus; _farmerCompoundCount = users[_adr].farmerCompoundCount; _lastWithdrawTime = users[_adr].lastWithdrawTime; } function initialize(uint256 amount) public{ if (!contractStarted) { if (msg.sender == owner) { require(marketEggs == 0); contractStarted = true; marketEggs = 144000000000; buyEggs(msg.sender, amount); } else revert("Contract not yet started."); } } function getBalance() public view returns (uint256) { return token_USDC.balanceOf(address(this)); } function getTimeStamp() public view returns (uint256) { return block.timestamp; } function getAvailableEarnings(address _adr) public view returns(uint256) { uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr)); return calculateEggSell(userEggs); } function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){ return SafeMath.div(SafeMath.mul(PSN, bs), SafeMath.add(PSNH, SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs), SafeMath.mul(PSNH, rt)), rt))); } function calculateEggSell(uint256 eggs) public view returns(uint256){ return calculateTrade(eggs, marketEggs, getBalance()); } function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){ return calculateTrade(eth, contractBalance, marketEggs); } function calculateEggBuySimple(uint256 eth) public view returns(uint256){ return calculateEggBuy(eth, getBalance()); } function getEggsYield(uint256 amount) public view returns(uint256,uint256) { uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount)); uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS); uint256 day = 1 days; uint256 eggsPerDay = day.mul(miners); uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount); return(miners, earningsPerDay); } function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){ return calculateTrade(eggs,marketEggs, getBalance().add(amount)); } function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) { return (totalStaked, totalDeposits, totalCompound, totalRefBonus); } function getMyMiners() public view returns(uint256){ return users[msg.sender].miners; } function getMyEggs() public view returns(uint256){ return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender)); } function getEggsSinceLastHatch(address adr) public view returns(uint256){ uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch); uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP); uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime); return secondsPassed.mul(users[adr].miners); } function min(uint256 a, uint256 b) private pure returns (uint256) { return a < b ? a : b; } function CHANGE_OWNERSHIP(address value) external { require(msg.sender == owner, "Admin use only."); owner = value; } function CHANGE_FEE1(address value) external { require(msg.sender == owner, "Admin use only."); fee1 = value; } function CHANGE_DEV1(address value) external { require(msg.sender == owner, "Admin use only."); dev1 = value; } // 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%, 1080000 - 8% // 959000 - 9%, 864000 - 10%, 720000 - 12%, 575424 - 15%, 540000 - 16%, 479520 - 18% function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value >= 479520 && value <= 2592000); EGGS_TO_HIRE_1MINERS = value; } function PRC_TAX(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value <= 100); TAX = value; } function PRC_REFERRAL(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value >= 10 && value <= 120); REFERRAL = value; } function PRC_MARKET_EGGS_DIVISOR(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value <= 50); MARKET_EGGS_DIVISOR = value; } function SET_WITHDRAWAL_TAX(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value <= 900); WITHDRAWAL_TAX = value; } function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value <= 12); COMPOUND_FOR_NO_TAX_WITHDRAWAL = value; } function BONUS_DAILY_COMPOUND(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value >= 10 && value <= 900); COMPOUND_BONUS = value; } function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value <= 30); COMPOUND_BONUS_MAX_TIMES = value; } function BONUS_COMPOUND_STEP(uint256 value) external { require(msg.sender == owner, "Admin use only."); require(value <= 24); COMPOUND_STEP = value * 60 * 60; } function SET_MIN_INVEST_LIMIT(uint256 value) external { require(msg.sender == owner, "Admin use only"); MIN_INVEST_LIMIT = value * 1e6; } function SET_CUTOFF_STEP(uint256 value) external { require(msg.sender == owner, "Admin use only"); CUTOFF_STEP = value * 60 * 60; } function SET_WITHDRAW_COOLDOWN(uint256 value) external { require(msg.sender == owner, "Admin use only"); require(value <= 24); WITHDRAW_COOLDOWN = value * 60 * 60; } function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external { require(msg.sender == owner, "Admin use only"); require(value >= 20); WALLET_DEPOSIT_LIMIT = value * 1e6; } }
308,318
11,817
b73412d74595117fe1094a4bf19eb5d6b33388f3b3f495a3be3d4a45cde3b4bd
19,320
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TY/TYHKHwhrxDNogEjBmUpHHMpzWZCojeCy5R_InvestmentClub_V1.sol
4,705
18,156
//SourceUnit: 6654.sol pragma solidity 0.5.12; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 // uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } function inc(uint a) internal pure returns(uint) { return(add(a, 1)); } function dec(uint a) internal pure returns(uint) { return(sub(a, 1)); } } contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = msg.sender; _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() private view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == msg.sender, "Ownable: caller is not the owner"); _; } function renounceOwnership() private onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) private onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Pausable is Ownable{ event Paused(address account); event Unpaused(address account); bool private _paused; constructor () internal { _paused = false; } function paused() private view returns (bool) { return _paused; } modifier whenNotPaused() { require(!_paused, "Pausable: paused"); _; } modifier whenPaused() { require(_paused, "Pausable: not paused"); _; } function pause() private onlyOwner whenNotPaused { _paused = true; emit Paused(msg.sender); } function unpause() private onlyOwner whenPaused { _paused = false; emit Unpaused(msg.sender); } } contract InvestmentClub_V1 is Pausable { using SafeMath for uint256; struct Deposit { uint256 depositTime; uint256 lastDepositTime; uint256 amount; uint256 validUntil; } struct DepositHistory { uint256 depositTime; uint256 lastDepositTime; uint256 amount; uint256 validUntil; bool IsCollect; } struct WithdrawTable { uint256 withdrawTime; uint256 amount; } struct PlayerReferral { uint256 createDate; address referral; uint256 depositAmount; uint256 withdrawAmount; uint256 commission; } struct Player { Deposit[] deposits; DepositHistory[] deposithistory; WithdrawTable[] withdrawtable; uint256 withdrawns; uint256 depositAmount; uint256 balance; uint256 validUntil; uint256 YouCanWithdraw; PlayerReferral[] playerReferrals; address payable usersReferral; bool isFirstDeposit; uint256 MytotalCountReferral; uint256 MytotalReferralEarn; uint256 MytotalWithdrawn; } uint256[] private PERIOD = [200 days]; //max profit days uint256 constant private MIN_DEPOSIT = 5000000; // minimum deposit 50 TRX uint256 constant private TEAM_PERCENT = 10; //10% uint256 private totalDeposit; address payable private team_wallet = address(0x412F24D0920A7B058093279A628364CEE1A431E775); uint256[] private RATE_DIVIDER = [8640000]; //profit per second 86400(1 day in seconds) * 100 (1% per day) =K 8640000 uint256[] private REF_PERCENT = [5];// referral deposit 5%, withdraw 5% uint256 public totalWithdrawn; mapping(address => Player) public users; event Deposits(address indexed user, uint256 amount); event adminFee(address indexed addr, address indexed wallet, uint256 amount); event RefFee(address indexed addr, address indexed referral, uint256 amount); event Fee(address indexed addr, address indexed referrer, uint256 amount); event Withdrawn(address indexed addr, uint256 amount); uint256 public totalUsers; uint256 public totalCountReferral; uint256 public totalReferralEarn; function isExistReferral(address referral) view private returns (bool){ PlayerReferral[] storage user = users[referral].playerReferrals; for (uint i; i< user.length;i++){ if (user[i].referral==msg.sender) return true; } } function isDeposited() public view returns(bool) { Player storage user = users[msg.sender]; if (user.isFirstDeposit == true) { return true; } } function UpdateReferralBalance(address referral,uint256 depositAmount, uint256 withdrawAmount, uint256 commission) private { if (msg.sender!=referral && referral!=team_wallet) { if (!isExistReferral(referral)) { Player storage user = users[referral]; user.playerReferrals.push(PlayerReferral(now,msg.sender, depositAmount,withdrawAmount,commission)); totalCountReferral=totalCountReferral.add(1); users[referral].MytotalCountReferral=users[referral].MytotalCountReferral.add(1); users[referral].MytotalReferralEarn=users[referral].MytotalReferralEarn.add(commission); } else { Player storage user = users[referral]; PlayerReferral[] memory ref = user.playerReferrals; uint256 i = 0; while (i < ref.length){ PlayerReferral memory getRef = ref[i]; if (getRef.referral==msg.sender) { PlayerReferral storage setRef = users[referral].playerReferrals[i]; setRef.depositAmount = setRef.depositAmount.add(depositAmount); setRef.withdrawAmount = getRef.withdrawAmount.add(withdrawAmount); setRef.commission = setRef.commission.add(commission); }i++; } totalReferralEarn=totalReferralEarn.add(commission); users[referral].MytotalReferralEarn=users[referral].MytotalReferralEarn.add(commission); } } } function deposit(address payable referral) public payable whenNotPaused { uint256 amount = msg.value; require(amount >= 1, "Your investment amount is less than the minimum amount!"); address addr = msg.sender; Player storage user = users[msg.sender]; Player storage getRef = users[referral]; if (users[addr].deposits.length==0) { totalUsers = totalUsers.add(1); } //Enable option transfer to the referall partner if (users[addr].usersReferral==address(0)) { if (getRef.isFirstDeposit==false) { user.usersReferral = team_wallet; team_wallet.transfer(amount.mul(TEAM_PERCENT.add(REF_PERCENT[0])).div(100)); } else { user.usersReferral = referral; team_wallet.transfer(amount.mul(TEAM_PERCENT).div(100)); referral.transfer(amount.mul(REF_PERCENT[0]).div(100)); UpdateReferralBalance(referral, amount, 0, amount.mul(REF_PERCENT[0]).div(100)); } } else { address payable SendRef = user.usersReferral; team_wallet.transfer(amount.mul(TEAM_PERCENT).div(100)); SendRef.transfer(amount.mul(REF_PERCENT[0]).div(100)); UpdateReferralBalance(SendRef, amount, 0, amount.mul(REF_PERCENT[0]).div(100)); } user.deposits.push(Deposit(now, now, amount, now.add(PERIOD[0]))); user.deposithistory.push(DepositHistory(now, now, amount, now.add(PERIOD[0]),false)); user.depositAmount = users[addr].depositAmount.add(amount); user.validUntil = now.add(PERIOD[0]); totalDeposit = totalDeposit.add(amount); user.isFirstDeposit=true; emit Deposits(addr, amount); } function withdraw() public{ address payable addr = msg.sender; address payable referral=users[addr].usersReferral; uint256 value = collect(); uint256 WithdrawFromAmount = value < address(this).balance ? value: (address(this).balance).sub(address(this).balance.mul(REF_PERCENT[0]).div(100)); //(address(this).balance);//.value.mul(REF_PERCENT[0]).div(100)); users[addr].withdrawtable.push(WithdrawTable(now,WithdrawFromAmount)); addr.transfer(WithdrawFromAmount); users[addr].YouCanWithdraw = value.sub(WithdrawFromAmount); UpdateReferralBalance(referral, 0, value, value.mul(REF_PERCENT[0]).div(100)); referral.transfer(WithdrawFromAmount.mul(REF_PERCENT[0]).div(100)); totalWithdrawn=totalWithdrawn.add(WithdrawFromAmount); users[addr].MytotalWithdrawn=users[addr].MytotalWithdrawn.add(WithdrawFromAmount); emit Withdrawn(addr, WithdrawFromAmount); } function collect() private returns(uint256){ address addr= msg.sender; Deposit[] storage invests = users[addr].deposits; uint256 profit = users[addr].YouCanWithdraw; uint256 i = 0; uint256 timeSpent=0; while (i < invests.length){ Deposit storage invest = invests[i]; if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){ uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime)); if (remainedTime > 0){ timeSpent = now.sub(invest.lastDepositTime); if (remainedTime <= timeSpent){ timeSpent = remainedTime; //Update deposit history DepositHistory[] storage invests_history = users[addr].deposithistory; invests_history[i].IsCollect=true; } invest.lastDepositTime = now; profit = profit.add(invest.amount.mul(timeSpent).div(RATE_DIVIDER[0])); } } i++; } return (profit); } function getUserCollectWithdraw () public view returns(uint256) { Deposit[] storage invests = users[msg.sender].deposits; uint256 profit = users[msg.sender].YouCanWithdraw; uint256 i = 0; uint256 timeSpent=0; while (i < invests.length){ Deposit storage invest = invests[i]; if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){ uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime)); if (remainedTime > 0){ timeSpent = now.sub(invest.lastDepositTime); if (remainedTime <= timeSpent){ timeSpent = remainedTime; } } profit += (invest.amount.mul(timeSpent).div(RATE_DIVIDER[0])); } i++; } return profit; } function getReferrals() public view returns (uint256[] memory, address[] memory, uint256[] memory, uint256[] memory, uint256[] memory) { Player storage user = users[msg.sender]; PlayerReferral[] memory ref = user.playerReferrals; uint256[] memory createDate = new uint256[](ref.length); address[] memory referralAddress = new address[](ref.length); uint256[] memory depositAmount = new uint256[](ref.length); uint256[] memory withdrawAmount = new uint256[](ref.length); uint256[] memory commission = new uint256[](ref.length); uint256 i = 0; while (i < ref.length){ PlayerReferral memory getRef = ref[i]; if (getRef.depositAmount > 0 || getRef.withdrawAmount>0) { createDate[i] = getRef.createDate; referralAddress[i] = getRef.referral; depositAmount[i] = getRef.depositAmount; withdrawAmount[i] = getRef.withdrawAmount; commission[i] = getRef.commission; }i++; } return (createDate,referralAddress,depositAmount,withdrawAmount,commission); } function getPlayerDeposit() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory) { Deposit[] memory invests = users[msg.sender].deposits; uint256[] memory baseTimes = new uint256[](invests.length); uint256[] memory lastCollectedTimes = new uint256[](invests.length); uint256[] memory values = new uint256[](invests.length); uint256[] memory calcSeconds = new uint256[](invests.length); uint256[] memory profit = new uint256[](invests.length); uint256[] memory validUntil = new uint256[](invests.length); uint256 i = 0; uint256 timeSpent = 0; while (i < invests.length){ Deposit memory invest = invests[i]; if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){ uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime)); if (remainedTime > 0){ timeSpent=now.sub(invest.lastDepositTime); if (remainedTime <= timeSpent){ timeSpent = remainedTime; } } baseTimes[i] = invest.depositTime; lastCollectedTimes[i] = invest.lastDepositTime; values[i] = invest.amount; calcSeconds[i] = timeSpent; profit[i] = (invest.amount * timeSpent).div(RATE_DIVIDER[0]); validUntil[i] = invest.depositTime.add(PERIOD[0]); }i++; } return (baseTimes, lastCollectedTimes, values, calcSeconds,profit,validUntil); } function getPlayerDepositHistory() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) { DepositHistory[] memory invests = users[msg.sender].deposithistory; uint256[] memory baseTimes = new uint256[](invests.length); uint256[] memory values = new uint256[](invests.length); uint256[] memory profit = new uint256[](invests.length); uint256[] memory validUntil = new uint256[](invests.length); bool[] memory IsCollect = new bool[](invests.length); uint256 i = 0; uint256 timeSpent = 0; while (i < invests.length){ DepositHistory memory invest = invests[i]; if (invest.lastDepositTime < invest.depositTime.add(PERIOD[0])){ uint256 remainedTime = PERIOD[0].sub(invest.lastDepositTime.sub(invest.depositTime)); if (remainedTime > 0){ timeSpent=now.sub(invest.lastDepositTime); if (remainedTime <= timeSpent){ timeSpent = remainedTime; } } baseTimes[i] = invest.depositTime; values[i] = invest.amount; profit[i] = (invest.amount * timeSpent).div(RATE_DIVIDER[0]); validUntil[i] = invest.depositTime.add(PERIOD[0]); IsCollect[i] = invest.IsCollect; }i++; } return (baseTimes, values, profit,validUntil,IsCollect); } function getPlayerWithdrawHistory() public view returns (uint256[] memory, uint256[] memory,uint256[] memory) { WithdrawTable[] memory invests = users[msg.sender].withdrawtable; uint256[] memory withdrawTime = new uint256[](invests.length); uint256[] memory values = new uint256[](invests.length); uint256[] memory lastime = new uint256[](invests.length); uint256 i = 0; while (i < invests.length){ WithdrawTable memory invest = invests[i]; if (invest.amount>0) { withdrawTime[i] = invest.withdrawTime; values[i] = invest.amount; }i++; } return (withdrawTime,values,lastime); } function getContractBalance() public view returns(uint256) { return address(this).balance; } function getTotalStats() public view returns (uint256[] memory) { uint256[] memory combined = new uint256[](10); combined[0] = totalDeposit; combined[1] = address(this).balance; combined[2] = totalUsers; combined[3] = totalCountReferral; combined[4] = totalReferralEarn; combined[5] = users[msg.sender].MytotalCountReferral; combined[6] = users[msg.sender].MytotalReferralEarn; combined[7] = totalWithdrawn; combined[8] = users[msg.sender].depositAmount; combined[9] = users[msg.sender].MytotalWithdrawn; return combined; } }
301,852
11,818
86fa7c2cddf96b92bc69e29c822fe911e479ccc7640b1384d620ed30f2f9868c
29,573
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/48/48cDd89a83B6353e5c54eF0e85bFDEcd61d4f9a9_ShibElon.sol
5,199
18,711
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 ShibElon 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 = 300000000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'ShibElon Official'; string private constant _symbol = 'SHIBELON'; uint256 private _taxFee = 400; uint256 private _burnFee = 200; uint public max_tx_size = 1000000000 ether; bool public isPaused = false; constructor () public { _rOwned[_msgSender()] = _rTotal; isAllowed[_msgSender()] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function toggleAllowed(address addr) external onlyOwner { isAllowed[addr] = !isAllowed[addr]; } function unpause() external returns (bool){ require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call"); isPaused = false; return true; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0x86376D6D438062ab66E3fCc134781EE9AD63231b, '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; } }
325,697
11,819
ec06c5247eccd66a5b054466c35c81919fa9fbc4bd968c059d1c847ab7d5c490
13,817
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/bd/bd38129dDC58675A77933C9e51E65c7b977A3855_Presale.sol
3,532
13,601
// SPDX-License-Identifier: MIT pragma solidity >=0.8.0; interface IToken { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); function decimals() external view returns (uint8); } contract Presale { struct AIRDROP { address user; uint256 claimable; uint256 claimed; } address public targetToken; address public contributeCoin; uint256 private constant RESOLUTION_CV_RATIO = 10 ** 9; uint256 public salePrice; mapping (address => uint256) public targetTokenRequested; mapping (address => uint256) public targetTokenClaimed; mapping (address => uint256) public coinContributed; uint256 public totalTargetTokenRequested; uint256 public totalCoinContributed; uint256 public minPerWallet; uint256 public maxPerWallet; uint256 public totalTargetCap; uint256 public startTimestamp; uint256 public endTimestamp; mapping(address => bool) public isWhitelisted; uint256 public saleType; address public owner; bool private initialized; mapping(address => AIRDROP) airdropContext; uint256 public totalAirdropClaimable; uint256 public claimableStart; uint256 public claimableEnd; uint256 public totalAirdropClaimed; event TransferOwnership(address _oldOwner, address _newOwner); event Requested(address user, uint256 deposit, uint256 coin); event Gifted(address user, uint256 amount); event Refunded(address user, uint256 amount, uint256 coin); event Whitelist(address[] users, bool set); event CanClaim(address indexed recipient, uint256 amount); event HasClaimed(address indexed recipient, uint256 amount); modifier onlyOwner() { require(msg.sender == owner, "Not owner"); _; } modifier isWhitelistMode() { require(saleType == 0, "Sale type is not set to WHITELIST"); _; } modifier isPublicMode() { require(saleType == 1, "Sale type is not set to PUBLIC_SALE"); _; } modifier whitelisted() { require(checkWhitelisted(msg.sender), "Not whitelisted account"); _; } modifier underWay() { require(block.timestamp >= startTimestamp, "Presale not started"); require(block.timestamp <= endTimestamp, "Presale ended"); _; } modifier whenExpired() { require(block.timestamp > endTimestamp, "Presale not ended"); _; } function initialize(address _targetToken, address _coinToken) external { require (!initialized, "Already initialized"); initialized = true; owner = msg.sender; emit TransferOwnership(address(0), owner); targetToken = _targetToken; contributeCoin = _coinToken; salePrice = RESOLUTION_CV_RATIO / 1000; // 1 $ZKASH = 0.001 $ETH minPerWallet = 10 * (10 ** 18); // 10 $ZKASH per wallet at minimum maxPerWallet = 5000 * (10 ** 18); // 5000 $ZKASH per wallet at maximum totalTargetCap = 2_000_000 * (10 ** 18); // 2m $ZKASH at maximum saleType = 0; // 0: whitelist, 1: public sale } function transferOwnership(address _newOwner) external onlyOwner { require(_newOwner != address(0), "Zero address"); emit TransferOwnership(owner, _newOwner); owner = _newOwner; } function renounceOwnership() external onlyOwner { emit TransferOwnership(owner, address(0)); owner = address(0); } function launchPresale(uint256 _secAfter, uint256 _secDuration) external onlyOwner { startTimestamp = block.timestamp + _secAfter; endTimestamp = block.timestamp + _secAfter + _secDuration; } function expandPresale(uint256 _secDuration) external onlyOwner underWay { endTimestamp = block.timestamp + _secDuration; } function updateVTokenPrice(uint256 _newSalePriceInResolution9) external onlyOwner { require(salePrice != _newSalePriceInResolution9, "Already set"); salePrice = _newSalePriceInResolution9; } function updateMinMaxTokenPerWallet(uint256 _minAmount, uint256 _maxAmount) external onlyOwner { minPerWallet = _minAmount; maxPerWallet = _maxAmount; } function setTotalCap(uint256 _totalAmount) external onlyOwner { totalTargetCap = _totalAmount; } function updateSaleType(uint256 _saleType) external onlyOwner { require(saleType != _saleType, "Already set"); require(saleType == 0 || saleType == 1, "Unknown sale type"); saleType = _saleType; } function setWhitelisted(address[] calldata users, bool set) external onlyOwner { uint256 i; for (i = 0; i < users.length; i ++) { if (isWhitelisted[users[i]] != set) { isWhitelisted[users[i]] = set; } } emit Whitelist(users, set); } function updateTokens(address _targetToken, address _coinToken) external onlyOwner { require(totalTargetTokenRequested == 0, "Unable to update token addresses"); targetToken = _targetToken; contributeCoin = _coinToken; } function convertC2V(uint256 _cAmount) internal view returns (uint256) { uint256 cDecimal = 18; if (contributeCoin != address(0)) { cDecimal = IToken(contributeCoin).decimals(); } uint256 vDecimal = IToken(targetToken).decimals(); return _cAmount * RESOLUTION_CV_RATIO * (10 ** vDecimal) / (salePrice * (10 ** cDecimal)); } function convertV2C(uint256 _vAmount) internal view returns (uint256) { uint256 cDecimal = 18; if (contributeCoin != address(0)) { cDecimal = IToken(contributeCoin).decimals(); } uint256 vDecimal = IToken(targetToken).decimals(); return _vAmount * salePrice * (10 ** cDecimal) / (RESOLUTION_CV_RATIO * (10 ** vDecimal)); } function sellVToken(address _to, uint256 _coinAmount) internal returns (uint256, uint256) { uint256 cReceived; if (contributeCoin == address(0)) { cReceived = msg.value; } else { address feeRx = address(this); uint256 _oldCBalance = IToken(contributeCoin).balanceOf(feeRx); IToken(contributeCoin).transferFrom(_to, feeRx, _coinAmount); uint256 _newCBalance = IToken(contributeCoin).balanceOf(feeRx); cReceived = _newCBalance - _oldCBalance; } uint256 targetAmount = convertC2V(cReceived); require(targetTokenRequested[_to] + targetAmount <= maxPerWallet, "Too much requested"); require(targetTokenRequested[_to] + targetAmount >= minPerWallet, "Too small requested"); targetTokenRequested[_to] += targetAmount; coinContributed[_to] += cReceived; totalTargetTokenRequested += targetAmount; totalCoinContributed += cReceived; return (targetAmount, cReceived); } function giftVToken(address _to, uint256 _vAmount) internal returns (uint256) { uint256 targetAmount = _vAmount; totalTargetTokenRequested += targetAmount; targetTokenRequested[_to] += targetAmount; return targetAmount; } function refundVToken(address to) internal returns (uint256, uint256) { uint256 targetAmount = targetTokenRequested[to]; uint256 coinAmount = coinContributed[to]; totalTargetTokenRequested -= targetTokenRequested[to]; targetTokenRequested[to] = 0; coinContributed[to] = 0; if (coinAmount > 0) { payCoin(to, coinAmount); } return (targetAmount, coinAmount); } function sellWhitelist(uint256 _coinAmount) external payable isWhitelistMode whitelisted() underWay { (uint256 target, uint256 coin) = sellVToken(msg.sender, _coinAmount); emit Requested(msg.sender, target, coin); } function sellPublic(uint256 _coinAmount) external payable isPublicMode underWay { (uint256 target, uint256 coin) = sellVToken(msg.sender, _coinAmount); emit Requested(msg.sender, target, coin); } function gift(address _to, uint256 _vAmount) external onlyOwner underWay { uint256 amount = giftVToken(_to, _vAmount); emit Gifted(_to, amount); } function forceRefund(address _user) external payable onlyOwner { (uint256 target, uint256 coin) = refundVToken(_user); emit Refunded(_user, target, coin); } function checkWhitelisted(address _user) public view returns (bool) { return isWhitelisted[_user]; } function recoverCoin(address _to, uint256 _amount) external payable onlyOwner { if (_amount == 0) { if (contributeCoin == address(0)) { _amount = address(this).balance; } else { _amount = IToken(contributeCoin).balanceOf(address(this)); } } payCoin(_to, _amount); } function payCoin(address _to, uint256 _amount) internal { if (contributeCoin == address(0)) { (bool success,) = payable(_to).call{value: _amount}(""); require(success, "Failed to recover"); } else { IToken(contributeCoin).transfer(_to, _amount); } } function claim(uint256 _amount) external payable whenExpired { address user = msg.sender; uint256 claimableAmount = getClaimableAmount(user); require(_amount <= claimableAmount, "Claiming too much"); // if (totalTargetCap < totalTargetTokenRequested) { // overflown // uint256 _targetTokenAmount = _amount * totalTargetCap / totalTargetTokenRequested; // IToken(targetToken).transfer(user, _targetTokenAmount); // payCoin(user, _totalCoinOverflownAmount * _amount / totalTargetTokenRequested); // } else { IToken(targetToken).transfer(user, _amount); // } targetTokenClaimed[user] += _amount; require(targetTokenClaimed[user] <= targetTokenRequested[user], "Claimed too much"); } function getClaimableAmount(address user) public view returns (uint256) { uint256 requestedAmount = targetTokenRequested[user]; uint256 claimedAmount = targetTokenClaimed[user]; uint256 ret; if (block.timestamp < endTimestamp) { ret = 0; // } else if (block.timestamp < endTimestamp + (30 days)) { // ret = ((requestedAmount * 80) / 100) - claimedAmount; // } else if (block.timestamp < endTimestamp + (60 days)) { // ret = ((requestedAmount * 90) / 100) - claimedAmount; } else { ret = requestedAmount - claimedAmount; } return ret; } /// @notice Allows owner to set a list of recipients to receive tokens /// @dev This may need to be called many times to set the full list of recipients function setAirdropRecipients(address[] calldata _recipients, uint256[] calldata _claimableAmount) external onlyOwner { require(_recipients.length == _claimableAmount.length, "Airdrop: invalid array length"); uint256 sum = totalAirdropClaimable; for (uint256 i = 0; i < _recipients.length; i++) { // sanity check that the address being set is consistent AIRDROP storage ad = airdropContext[_recipients[i]]; ad.user = _recipients[i]; ad.claimable += _claimableAmount[i]; emit CanClaim(_recipients[i], _claimableAmount[i]); unchecked { sum += _claimableAmount[i]; } } // sanity check that the current has been sufficiently allocated require(IToken(targetToken).balanceOf(address(this)) >= sum, "Airdrop: not enough balance"); totalAirdropClaimable = sum; } /// @notice Allows a recipient to claim their tokens /// @dev Can only be called during the claim period function airdropClaim() external { require(block.timestamp >= claimableStart, "Airdrop: claim not started"); require(block.timestamp < claimableEnd, "Airdrop: claim ended"); AIRDROP storage ad = airdropContext[msg.sender]; require(ad.user == msg.sender, "Airdrop: not requested"); uint256 amount = ad.claimable - ad.claimed; require(amount > 0, "Airdrop: nothing to claim"); ad.claimable = ad.claimed; totalAirdropClaimed += amount; // we don't use safeTransfer since impl is assumed to be OZ require(IToken(targetToken).transfer(msg.sender, amount), "Airdrop: fail token transfer"); emit HasClaimed(msg.sender, amount); } function getAirdropClaimableAmount(address user) external view returns (uint256) { AIRDROP storage ad = airdropContext[user]; require(ad.user == user, "Airdrop: not requested"); uint256 amount = ad.claimable - ad.claimed; return amount; } function launchAirdrop(uint256 _secAfter, uint256 _secDuration) external onlyOwner { claimableStart = block.timestamp + _secAfter; claimableEnd = block.timestamp + _secAfter + _secDuration; } receive() external payable {} }
46,332
11,820
2c826bdecee612c9818e1b6c8a9bce11aaf6e1b340e97712cd77c1dbc597cfbe
23,777
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TY/TYCaR2BiKcHC4kZ6noPqDAb1Ymd3XcyShh_iTronyx.sol
6,559
22,638
//SourceUnit: Itronyx.sol pragma solidity ^0.5.4; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } library Objects { struct Investment { uint256 planId; uint256 investmentDate; uint256 investment; uint256 lastWithdrawalDate; uint256 currentDividends; bool isExpired; } struct Plan { uint256 dailyInterest; uint256 term; //0 means unlimited } struct Investor { address addr; uint256 referrerEarnings; uint256 availableReferrerEarnings; uint256 referrer; uint256 planCount; mapping(uint256 => Investment) plans; uint256 level1RefCount; uint256 level2RefCount; uint256 level3RefCount; uint256 level4RefCount; uint256 level5RefCount; uint256 timer; uint256 turnover; uint256 currentLevel; uint256 bonusEarnings; } struct Bonus { uint256 gap; uint256 prize; } } contract Ownable { address public owner; event onOwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { require(_newOwner != address(0)); emit onOwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract iTronyx is Ownable { using SafeMath for uint256; uint256 public constant DEVELOPER_RATE = 20; //per thousand uint256 public constant MARKETING_RATE = 30; uint256 public constant ADMIN_RATE = 90; uint256 public constant REFERENCE_RATE = 115; uint256 public constant REFERENCE_LEVEL1_RATE = 50; uint256 public constant REFERENCE_LEVEL2_RATE = 30; uint256 public constant REFERENCE_LEVEL3_RATE = 20; uint256 public constant REFERENCE_LEVEL4_RATE = 10; uint256 public constant REFERENCE_LEVEL5_RATE = 5; uint256 public constant ACTIVATION_TIME = 1606845600; uint256 public constant MINIMUM = 50000000; //minimum investment needed uint256 public constant REFERRER_CODE = 6666; //default uint256 public latestReferrerCode; uint256 private totalInvestments_; address payable private developerAccount_; address payable private marketingAccount_; address payable private adminAccount_; address payable private referenceAccount_; mapping(address => uint256) public address2UID; mapping(uint256 => Objects.Investor) public uid2Investor; mapping(uint256 => Objects.Bonus) public bonusLevels; Objects.Plan[] private investmentPlans_; event onInvest(address investor, uint256 amount); event onGrant(address grantor, address beneficiary, uint256 amount); event onWithdraw(address investor, uint256 amount); constructor(address payable adminAccount, address payable marketingAccount) public { developerAccount_ = msg.sender; marketingAccount_ = marketingAccount; adminAccount_ = adminAccount; referenceAccount_ = msg.sender; _init(); } function() external payable { if (msg.value == 0) { withdraw(); } else { invest(0, 0); //default to buy plan 0, no referrer } } function checkIn() public { } function getMarketingAccount() public view onlyOwner returns (address) { return marketingAccount_; } function getDeveloperAccount() public view onlyOwner returns (address) { return developerAccount_; } function getReferenceAccount() public view onlyOwner returns (address) { return referenceAccount_; } function _init() private { latestReferrerCode = REFERRER_CODE; address2UID[msg.sender] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = msg.sender; uid2Investor[latestReferrerCode].referrer = 0; uid2Investor[latestReferrerCode].planCount = 0; investmentPlans_.push(Objects.Plan(240, 5*60*60*24)); //24% per day for 5 days investmentPlans_.push(Objects.Plan(210, 7*60*60*24)); //21% per day for 7 days investmentPlans_.push(Objects.Plan(180, 10*60*60*24)); //18% per day for 10 days investmentPlans_.push(Objects.Plan(150, 14*60*60*24)); //15% per day for 14 days bonusLevels[1] = Objects.Bonus(15000*1e6,200*1e6); bonusLevels[2] = Objects.Bonus(50000*1e6,300*1e6); bonusLevels[3] = Objects.Bonus(100000*1e6,500*1e6); bonusLevels[4] = Objects.Bonus(500000*1e6,4000*1e6); bonusLevels[5] = Objects.Bonus(1000000*1e6,15000*1e6); bonusLevels[6] = Objects.Bonus(5000000*1e6,80000*1e6); bonusLevels[7] = Objects.Bonus(10000000*1e6,200000*1e6); bonusLevels[8] = Objects.Bonus(20000000*1e6,1300000*1e6); bonusLevels[9] = Objects.Bonus(50000000*1e6,2400000*1e6); } function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory) { uint256[] memory ids = new uint256[](investmentPlans_.length); uint256[] memory interests = new uint256[](investmentPlans_.length); uint256[] memory terms = new uint256[](investmentPlans_.length); for (uint256 i = 0; i < investmentPlans_.length; i++) { Objects.Plan storage plan = investmentPlans_[i]; ids[i] = i; interests[i] = plan.dailyInterest; terms[i] = plan.term; } return (ids, interests, terms); } function getTotalInvestments() public view returns (uint256){ return totalInvestments_; } function getBalance() public view returns (uint256) { return address(this).balance; } function getUIDByAddress(address _addr) public view returns (uint256) { return address2UID[_addr]; } function getTimer(address _addr) public view returns (uint256) { return uid2Investor[address2UID[_addr]].timer; } function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256,uint256,uint256, uint256, uint256[] memory, uint256[] memory,uint256[] memory) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info."); } Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory refStats = new uint256[](2); uint256[] memory newDividends = new uint256[](investor.planCount); uint256[] memory currentDividends = new uint256[](investor.planCount); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate != 0, "wrong investment date"); currentDividends[i] = investor.plans[i].currentDividends; if (investor.plans[i].isExpired) { newDividends[i] = 0; } else { if (investmentPlans_[investor.plans[i].planId].term > 0) { if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate); } else { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate); } } else { newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate); } } } refStats[0] = investor.turnover; refStats[1] = investor.bonusEarnings; return (investor.referrerEarnings, investor.availableReferrerEarnings, investor.referrer, investor.level1RefCount, investor.level2RefCount, investor.level3RefCount, investor.level4RefCount, investor.level5RefCount, investor.planCount, currentDividends, newDividends, refStats); } function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) { if (msg.sender != owner) { require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info."); } Objects.Investor storage investor = uid2Investor[_uid]; uint256[] memory planIds = new uint256[](investor.planCount); uint256[] memory investmentDates = new uint256[](investor.planCount); uint256[] memory investments = new uint256[](investor.planCount); uint256[] memory currentDividends = new uint256[](investor.planCount); bool[] memory isExpireds = new bool[](investor.planCount); for (uint256 i = 0; i < investor.planCount; i++) { require(investor.plans[i].investmentDate!=0,"wrong investment date"); planIds[i] = investor.plans[i].planId; currentDividends[i] = investor.plans[i].currentDividends; investmentDates[i] = investor.plans[i].investmentDate; investments[i] = investor.plans[i].investment; if (investor.plans[i].isExpired) { isExpireds[i] = true; } else { isExpireds[i] = false; if (investmentPlans_[investor.plans[i].planId].term > 0) { if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) { isExpireds[i] = true; } } } } return (planIds, investmentDates, investments, currentDividends, isExpireds); } function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) { if (_referrerCode >= REFERRER_CODE) { //require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code"); if (uid2Investor[_referrerCode].addr == address(0)) { _referrerCode = 0; } } else { _referrerCode = 0; } address addr = _addr; latestReferrerCode = latestReferrerCode.add(1); address2UID[addr] = latestReferrerCode; uid2Investor[latestReferrerCode].addr = addr; uid2Investor[latestReferrerCode].referrer = _referrerCode; uid2Investor[latestReferrerCode].planCount = 0; if (_referrerCode >= REFERRER_CODE) { uint256 _ref1 = _referrerCode; uint256 _ref2 = uid2Investor[_ref1].referrer; uint256 _ref3 = uid2Investor[_ref2].referrer; uint256 _ref4 = uid2Investor[_ref3].referrer; uint256 _ref5 = uid2Investor[_ref4].referrer; uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1); if (_ref2 >= REFERRER_CODE) { uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1); } if (_ref3 >= REFERRER_CODE) { uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1); } if (_ref4 >= REFERRER_CODE) { uid2Investor[_ref4].level4RefCount = uid2Investor[_ref4].level4RefCount.add(1); } if (_ref5 >= REFERRER_CODE) { uid2Investor[_ref5].level5RefCount = uid2Investor[_ref5].level5RefCount.add(1); } } return (latestReferrerCode); } function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) { require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id"); require(ACTIVATION_TIME < now , "NOT_YET_LAUNCHED"); require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement"); uint256 uid = address2UID[_addr]; if (uid == 0) { uid = _addInvestor(_addr, _referrerCode); //new user } else {//old user //do nothing, referrer is permenant } uint256 planCount = uid2Investor[uid].planCount; Objects.Investor storage investor = uid2Investor[uid]; investor.plans[planCount].planId = _planId; investor.plans[planCount].investmentDate = block.timestamp; investor.plans[planCount].lastWithdrawalDate = block.timestamp; investor.plans[planCount].investment = _amount; investor.plans[planCount].currentDividends = 0; investor.plans[planCount].isExpired = false; investor.planCount = investor.planCount.add(1); _calculateReferrerReward(_amount, investor.referrer); totalInvestments_ = totalInvestments_.add(_amount); uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000); developerAccount_.transfer(developerPercentage); uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000); marketingAccount_.transfer(marketingPercentage); uint256 adminPercentage = (_amount.mul(ADMIN_RATE)).div(1000); adminAccount_.transfer(adminPercentage); return true; } function grant(address addr, uint256 _planId) public payable { uint256 grantorUid = address2UID[msg.sender]; bool isAutoAddReferrer = true; uint256 referrerCode = 0; if (grantorUid != 0 && isAutoAddReferrer) { referrerCode = grantorUid; } if (_invest(addr,_planId,referrerCode,msg.value)) { emit onGrant(msg.sender, addr, msg.value); } } function invest(uint256 _referrerCode, uint256 _planId) public payable { if (_invest(msg.sender, _planId, _referrerCode, msg.value)) { emit onInvest(msg.sender, msg.value); } } function withdraw() public { uint256 uid = address2UID[msg.sender]; require(uid != 0, "Can not withdraw because no any investments"); uint256 withdrawalAmount = 0; require(uid2Investor[uid].timer < now, "withdrawal is available only once every 24 hours"); uid2Investor[uid].timer = now + 24 hours; for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) { if (uid2Investor[uid].plans[i].isExpired) { continue; } Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId]; bool isExpired = false; uint256 withdrawalDate = block.timestamp; if (plan.term > 0) { uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term); if (withdrawalDate >= endTime) { withdrawalDate = endTime; isExpired = true; } } uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate); withdrawalAmount += amount; uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate; uid2Investor[uid].plans[i].isExpired = isExpired; uid2Investor[uid].plans[i].currentDividends += amount; } msg.sender.transfer(withdrawalAmount); if (uid2Investor[uid].availableReferrerEarnings>0) { msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings); uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings); uid2Investor[uid].availableReferrerEarnings = 0; } emit onWithdraw(msg.sender, withdrawalAmount); } function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) { return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24); } function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private { uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000); if (_referrerCode != 0) { uint256 _ref1 = _referrerCode; uint256 _ref2 = uid2Investor[_ref1].referrer; uint256 _ref3 = uid2Investor[_ref2].referrer; uint256 _ref4 = uid2Investor[_ref3].referrer; uint256 _ref5 = uid2Investor[_ref4].referrer; uint256 _refAmount = 0; if (_ref1 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings); uid2Investor[_ref1].turnover = _investment.add(uid2Investor[_ref1].turnover); if(uid2Investor[_ref1].currentLevel < 9 && bonusLevels[uid2Investor[_ref1].currentLevel + 1].gap <= uid2Investor[_ref1].turnover){ uid2Investor[_ref1].availableReferrerEarnings = bonusLevels[uid2Investor[_ref1].currentLevel + 1].prize.add(uid2Investor[_ref1].availableReferrerEarnings); uid2Investor[_ref1].currentLevel++; uid2Investor[_ref1].bonusEarnings = bonusLevels[uid2Investor[_ref1].currentLevel].prize.add(uid2Investor[_ref1].bonusEarnings); } } if (_ref2 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings); uid2Investor[_ref2].turnover = (_investment.div(2)).add(uid2Investor[_ref2].turnover); if(uid2Investor[_ref2].currentLevel < 9 && bonusLevels[uid2Investor[_ref2].currentLevel + 1].gap <= uid2Investor[_ref2].turnover){ uid2Investor[_ref2].availableReferrerEarnings = bonusLevels[uid2Investor[_ref2].currentLevel + 1].prize.add(uid2Investor[_ref2].availableReferrerEarnings); uid2Investor[_ref2].currentLevel++; uid2Investor[_ref2].bonusEarnings = bonusLevels[uid2Investor[_ref2].currentLevel].prize.add(uid2Investor[_ref2].bonusEarnings); } } if (_ref3 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings); uid2Investor[_ref3].turnover = (_investment.div(4)).add(uid2Investor[_ref3].turnover); if(uid2Investor[_ref3].currentLevel < 9 && bonusLevels[uid2Investor[_ref3].currentLevel + 1].gap <= uid2Investor[_ref3].turnover){ uid2Investor[_ref3].availableReferrerEarnings = bonusLevels[uid2Investor[_ref3].currentLevel + 1].prize.add(uid2Investor[_ref3].availableReferrerEarnings); uid2Investor[_ref3].currentLevel++; uid2Investor[_ref3].bonusEarnings = bonusLevels[uid2Investor[_ref3].currentLevel].prize.add(uid2Investor[_ref3].bonusEarnings); } } if (_ref4 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref4].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref4].availableReferrerEarnings); uid2Investor[_ref4].turnover = (_investment.div(10)).add(uid2Investor[_ref4].turnover); if(uid2Investor[_ref4].currentLevel < 9 && bonusLevels[uid2Investor[_ref4].currentLevel + 1].gap <= uid2Investor[_ref4].turnover){ uid2Investor[_ref4].availableReferrerEarnings = bonusLevels[uid2Investor[_ref4].currentLevel + 1].prize.add(uid2Investor[_ref4].availableReferrerEarnings); uid2Investor[_ref4].currentLevel++; uid2Investor[_ref4].bonusEarnings = bonusLevels[uid2Investor[_ref4].currentLevel].prize.add(uid2Investor[_ref4].bonusEarnings); } } if (_ref5 != 0) { _refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000); _allReferrerAmount = _allReferrerAmount.sub(_refAmount); uid2Investor[_ref5].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref5].availableReferrerEarnings); uid2Investor[_ref5].turnover = (_investment.div(20)).add(uid2Investor[_ref5].turnover); if(uid2Investor[_ref5].currentLevel < 9 && bonusLevels[uid2Investor[_ref5].currentLevel + 1].gap <= uid2Investor[_ref5].turnover){ uid2Investor[_ref5].availableReferrerEarnings = bonusLevels[uid2Investor[_ref5].currentLevel + 1].prize.add(uid2Investor[_ref5].availableReferrerEarnings); uid2Investor[_ref5].currentLevel++; uid2Investor[_ref5].bonusEarnings = bonusLevels[uid2Investor[_ref5].currentLevel].prize.add(uid2Investor[_ref5].bonusEarnings); } } } if (_allReferrerAmount > 0) { referenceAccount_.transfer(_allReferrerAmount); } } }
302,490
11,821
eda3b3f0c5bfc2c6876c25cbd37b1e452ea52fc568721eaafdc9a4fd80f85b68
13,508
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x05af72594440cf75c0fdcbbd9993fc26f62c7afc.sol
3,707
12,754
pragma solidity ^0.4.25; // THT Token Owners 10% (instantly) // Referral 10% (can withdraw instantly) // Key holders dividend: 30% (instantly? Till the end?) // Marketing: 5% // Final pot: 30% // Next pot: 15% // Total: 100% 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; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } } interface TwelveHourTokenInterface { function fallback() external payable; function buy(address _referredBy) external payable returns (uint256); function exit() external; } contract TwelveHourAuction { bool init = false; using SafeMath for uint256; address owner; uint256 public round = 0; uint256 public nextPot = 0; uint256 public profitTHT = 0; // setting percent twelve hour auction uint256 constant private THT_TOKEN_OWNERS = 10; uint256 constant private KEY_HOLDERS_DIVIDEND = 30; uint256 constant private REFERRAL = 10; uint256 constant private FINAL_POT = 30; // uint256 constant private NEXT_POT = 15; uint256 constant private MARKETING = 5; uint256 constant private MAGINITUDE = 2 ** 64; uint256 constant private HALF_TIME = 12 hours; uint256 constant private KEY_PRICE_DEFAULT = 0.005 ether; uint256 constant private VERIFY_REFERRAL_PRICE= 0.01 ether; // uint256 public stakingRequirement = 2 ether; address public twelveHourTokenAddress; TwelveHourTokenInterface public TwelveHourToken; mapping(uint256 => Game) public games; // bonus info mapping(address => Player) public players; mapping(address => bool) public referrals; address[10] public teamMarketing; struct Game { uint256 round; uint256 finalPot; uint256 profitPerShare; address keyHolder; uint256 keyLevel; uint256 endTime; bool ended; } // distribute gen portion to key holders struct Player { uint256 curentRound; uint256 lastRound; uint256 bonus; uint256 keys; // total key in round uint256 dividends; uint256 referrals; int256 payouts; } event Buy(uint256 round, address buyer, uint256 amount, uint256 keyLevel); event EndRound(uint256 round, uint256 finalPot, address keyHolder, uint256 keyLevel, uint256 endTime); event Withdraw(address player, uint256 amount); event WithdrawReferral(address player, uint256 amount); modifier onlyOwner() { require(msg.sender == owner); _; } modifier disableContract() { require(tx.origin == msg.sender); _; } constructor() public { owner = msg.sender; // setting default team marketing for (uint256 idx = 0; idx < 10; idx++) { teamMarketing[idx] = owner; } } function () public payable { if (msg.sender != twelveHourTokenAddress) buy(0x0); } function setTwelveHourToken(address _addr) public onlyOwner { twelveHourTokenAddress = _addr; TwelveHourToken = TwelveHourTokenInterface(twelveHourTokenAddress); } function setTeamMaketing(address _addr, uint256 _idx) public onlyOwner { teamMarketing[_idx] = _addr; } function verifyReferrals() public payable disableContract { require(msg.value >= VERIFY_REFERRAL_PRICE); referrals[msg.sender] = true; owner.transfer(msg.value); } // -------------------------------------------------------------------------- // SETUP GAME // -------------------------------------------------------------------------- function startGame() public onlyOwner { require(init == false); init = true; games[round].ended = true; startRound(); } function startRound() private { require(games[round].ended == true); round = round + 1; uint256 endTime = now + HALF_TIME; games[round] = Game(round, nextPot, 0, 0x0, 1, endTime, false); nextPot = 0; } function endRound() private disableContract { require(games[round].ended == false && games[round].endTime <= now); Game storage g = games[round]; address keyHolder = g.keyHolder; g.ended = true; players[keyHolder].bonus += g.finalPot; startRound(); // uint256 round, uint256 finalPot, address keyHolder, uint256 keyLevel, uint256 endTime emit EndRound(g.round, g.finalPot, g.keyHolder, g.keyLevel, g.endTime); } // ------------------------------------------------------------------------------ // BUY KEY // ------------------------------------------------------------------------------ function buy(address _referral) public payable disableContract { require(init == true); require(games[round].ended == false); require(msg.sender != _referral); if (games[round].endTime <= now) endRound(); Game storage g = games[round]; uint256 keyPrice = SafeMath.mul(g.keyLevel, KEY_PRICE_DEFAULT); uint256 repay = SafeMath.sub(msg.value, keyPrice); // uint256 _referralBonus = SafeMath.div(SafeMath.mul(keyPrice, REFERRAL), 100); uint256 _profitTHT = SafeMath.div(SafeMath.mul(keyPrice, THT_TOKEN_OWNERS), 100); uint256 _dividends = SafeMath.div(SafeMath.mul(keyPrice, KEY_HOLDERS_DIVIDEND), 100); uint256 _marketingFee = SafeMath.div(SafeMath.mul(keyPrice, MARKETING), 100); uint256 _finalPot = SafeMath.div(SafeMath.mul(keyPrice, FINAL_POT), 100); uint256 _nextPot = keyPrice - (_referralBonus + _profitTHT + _dividends + _marketingFee + _finalPot); if (msg.value < keyPrice) revert(); if (repay > 0) msg.sender.transfer(repay); // repay to player if (_referral != 0x0 && referrals[_referral] == true) players[_referral].referrals += _referralBonus; else owner.transfer(_referralBonus); uint256 _fee = _dividends * MAGINITUDE; nextPot = SafeMath.add(nextPot, _nextPot); profitTHT = SafeMath.add(profitTHT, _profitTHT); if (g.keyLevel > 1) { g.profitPerShare += (_dividends * MAGINITUDE / g.keyLevel); _fee = _fee - (_fee - (1 * (_dividends * MAGINITUDE / g.keyLevel))); } int256 _updatedPayouts = (int256) (g.profitPerShare * 1 - _fee); updatePlayer(msg.sender, _updatedPayouts); // update game updateGame(_finalPot); sendToTeamMaketing(_marketingFee); sendProfitTTH(); emit Buy(round, msg.sender, keyPrice, games[round].keyLevel); } function withdraw() public disableContract { if (games[round].ended == false && games[round].endTime <= now) endRound(); if (games[players[msg.sender].curentRound].ended == true) updatePlayerEndRound(msg.sender); Player storage p = players[msg.sender]; uint256 _dividends = calculateDividends(msg.sender, p.curentRound); uint256 balance = SafeMath.add(p.bonus, _dividends); balance = SafeMath.add(balance, p.dividends); require(balance > 0); if (address(this).balance >= balance) { p.bonus = 0; p.dividends = 0; if (p.curentRound == round) p.payouts += (int256) (_dividends * MAGINITUDE); msg.sender.transfer(balance); emit Withdraw(msg.sender, balance); } } function withdrawReferral() public disableContract { Player storage p = players[msg.sender]; uint256 balance = p.referrals; require(balance > 0); if (address(this).balance >= balance) { p.referrals = 0; msg.sender.transfer(balance); emit WithdrawReferral(msg.sender, balance); } } function myDividends(address _addr) public view returns(uint256 _dividends // bonus + dividends) { Player memory p = players[_addr]; Game memory g = games[p.curentRound]; _dividends = p.bonus + p.dividends; _dividends+= calculateDividends(_addr, p.curentRound); if (g.ended == false && g.endTime <= now && g.keyHolder == _addr) { _dividends += games[p.curentRound].finalPot; } } function getData(address _addr) public view returns(uint256 _round, uint256 _finalPot, uint256 _endTime, uint256 _keyLevel, uint256 _keyPrice, address _keyHolder, bool _ended, // player info uint256 _playerDividends, uint256 _playerReferrals) { _round = round; Game memory g = games[_round]; _finalPot = g.finalPot; _endTime = g.endTime; _keyLevel = g.keyLevel; _keyPrice = _keyLevel * KEY_PRICE_DEFAULT; _keyHolder= g.keyHolder; _ended = g.ended; // player _playerReferrals = players[_addr].referrals; _playerDividends = myDividends(_addr); } function calculateDividends(address _addr, uint256 _round) public view returns(uint256 _devidends) { Game memory g = games[_round]; Player memory p = players[_addr]; if (p.curentRound == _round && p.lastRound < _round && _round != 0) _devidends = (uint256) ((int256) (g.profitPerShare * p.keys) - p.payouts) / MAGINITUDE; } function totalEthereumBalance() public view returns (uint256) { return address(this).balance; } // --------------------------------------------------------------------------------------------- // INTERNAL FUNCTION // --------------------------------------------------------------------------------------------- function updatePlayer(address _addr, int256 _updatedPayouts) private { Player storage p = players[_addr]; if (games[p.curentRound].ended == true) updatePlayerEndRound(_addr); if (p.curentRound != round) p.curentRound = round; p.keys += 1; p.payouts += (int256)(_updatedPayouts); } function updatePlayerEndRound(address _addr) private { Player storage p = players[_addr]; uint256 dividends = calculateDividends(_addr, p.curentRound); p.dividends = SafeMath.add(p.dividends, dividends); p.lastRound = p.curentRound; p.keys = 0; p.payouts = 0; } function updateGame(uint256 _finalPot) private { Game storage g = games[round]; // Final pot: 30% g.finalPot = SafeMath.add(g.finalPot, _finalPot); // update key holder g.keyHolder = msg.sender; // reset end time game uint256 endTime = now + HALF_TIME; endTime = endTime - 10 * g.keyLevel; if (endTime <= now) endTime = now; g.endTime = endTime; // update key level g.keyLevel += 1; } function sendToTeamMaketing(uint256 _marketingFee) private { // price * maketing / 100 * 10 /100 = price * maketing * 10 / 10000 uint256 profit = SafeMath.div(SafeMath.mul(_marketingFee, 10), 100); for (uint256 idx = 0; idx < 10; idx++) { teamMarketing[idx].transfer(profit); } } function sendProfitTTH() private { uint256 balanceContract = totalEthereumBalance(); buyTHT(calEthSendToTHT(profitTHT)); exitTHT(); uint256 currentBalanceContract = totalEthereumBalance(); uint256 ethSendToTHT = SafeMath.sub(balanceContract, currentBalanceContract); if (ethSendToTHT > profitTHT) { // reset profit THT profitTHT = 0; nextPot = SafeMath.sub(nextPot, SafeMath.sub(ethSendToTHT, profitTHT)); } else { profitTHT = SafeMath.sub(profitTHT, ethSendToTHT); } } function calEthSendToTHT(uint256 _eth) private pure returns(uint256 _value) { _value = SafeMath.div(SafeMath.mul(_eth, 100), 64); } // conect to tht contract function buyTHT(uint256 _value) private { TwelveHourToken.fallback.value(_value)(); } function exitTHT() private { TwelveHourToken.exit(); } }
214,002
11,822
32a2a22dc031a273ca80c8495e740a99f99e6b9269257ff034c204f61c0c1fb3
13,032
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/da/DA4472B161e854489e3724fFa44918a04b4Af9Cc_ve_dist.sol
3,490
12,406
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity 0.8.11; interface erc20 { function totalSupply() external view returns (uint256); function transfer(address recipient, uint amount) external returns (bool); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function balanceOf(address) external view returns (uint); function transferFrom(address sender, address recipient, uint amount) external returns (bool); function approve(address spender, uint value) external returns (bool); } library Math { function min(uint a, uint b) internal pure returns (uint) { return a < b ? a : b; } function max(uint a, uint b) internal pure returns (uint) { return a >= b ? a : b; } } interface VotingEscrow { struct Point { int128 bias; int128 slope; // # -dweight / dt uint256 ts; uint256 blk; // block } function user_point_epoch(uint tokenId) external view returns (uint); function epoch() external view returns (uint); function user_point_history(uint tokenId, uint loc) external view returns (Point memory); function point_history(uint loc) external view returns (Point memory); function checkpoint() external; function deposit_for(uint tokenId, uint value) external; function token() external view returns (address); } contract ve_dist { event CheckpointToken(uint time, uint tokens); event Claimed(uint tokenId, uint amount, uint claim_epoch, uint max_epoch); uint constant WEEK = 7 * 86400; uint public start_time; uint public time_cursor; mapping(uint => uint) public time_cursor_of; mapping(uint => uint) public user_epoch_of; uint public last_token_time; uint[1000000000000000] public tokens_per_week; address public voting_escrow; address public token; uint public token_last_balance; uint[1000000000000000] public ve_supply; address public depositor; constructor(address _voting_escrow) { uint _t = block.timestamp / WEEK * WEEK; start_time = _t; last_token_time = _t; time_cursor = _t; address _token = VotingEscrow(_voting_escrow).token(); token = _token; voting_escrow = _voting_escrow; depositor = msg.sender; erc20(_token).approve(_voting_escrow, type(uint).max); } function timestamp() external view returns (uint) { return block.timestamp / WEEK * WEEK; } function _checkpoint_token() internal { uint token_balance = erc20(token).balanceOf(address(this)); uint to_distribute = token_balance - token_last_balance; token_last_balance = token_balance; uint t = last_token_time; uint since_last = block.timestamp - t; last_token_time = block.timestamp; uint this_week = t / WEEK * WEEK; uint next_week = 0; for (uint i = 0; i < 20; i++) { next_week = this_week + WEEK; if (block.timestamp < next_week) { if (since_last == 0 && block.timestamp == t) { tokens_per_week[this_week] += to_distribute; } else { tokens_per_week[this_week] += to_distribute * (block.timestamp - t) / since_last; } break; } else { if (since_last == 0 && next_week == t) { tokens_per_week[this_week] += to_distribute; } else { tokens_per_week[this_week] += to_distribute * (next_week - t) / since_last; } } t = next_week; this_week = next_week; } emit CheckpointToken(block.timestamp, to_distribute); } function checkpoint_token() external { assert(msg.sender == depositor); _checkpoint_token(); } function _find_timestamp_epoch(address ve, uint _timestamp) internal view returns (uint) { uint _min = 0; uint _max = VotingEscrow(ve).epoch(); for (uint i = 0; i < 128; i++) { if (_min >= _max) break; uint _mid = (_min + _max + 2) / 2; VotingEscrow.Point memory pt = VotingEscrow(ve).point_history(_mid); if (pt.ts <= _timestamp) { _min = _mid; } else { _max = _mid - 1; } } return _min; } function _find_timestamp_user_epoch(address ve, uint tokenId, uint _timestamp, uint max_user_epoch) internal view returns (uint) { uint _min = 0; uint _max = max_user_epoch; for (uint i = 0; i < 128; i++) { if (_min >= _max) break; uint _mid = (_min + _max + 2) / 2; VotingEscrow.Point memory pt = VotingEscrow(ve).user_point_history(tokenId, _mid); if (pt.ts <= _timestamp) { _min = _mid; } else { _max = _mid -1; } } return _min; } function ve_for_at(uint _tokenId, uint _timestamp) external view returns (uint) { address ve = voting_escrow; uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId); uint epoch = _find_timestamp_user_epoch(ve, _tokenId, _timestamp, max_user_epoch); VotingEscrow.Point memory pt = VotingEscrow(ve).user_point_history(_tokenId, epoch); return Math.max(uint(int256(pt.bias - pt.slope * (int128(int256(_timestamp - pt.ts))))), 0); } function _checkpoint_total_supply() internal { address ve = voting_escrow; uint t = time_cursor; uint rounded_timestamp = block.timestamp / WEEK * WEEK; VotingEscrow(ve).checkpoint(); for (uint i = 0; i < 20; i++) { if (t > rounded_timestamp) { break; } else { uint epoch = _find_timestamp_epoch(ve, t); VotingEscrow.Point memory pt = VotingEscrow(ve).point_history(epoch); int128 dt = 0; if (t > pt.ts) { dt = int128(int256(t - pt.ts)); } ve_supply[t] = Math.max(uint(int256(pt.bias - pt.slope * dt)), 0); } t += WEEK; } time_cursor = t; } function checkpoint_total_supply() external { _checkpoint_total_supply(); } function _claim(uint _tokenId, address ve, uint _last_token_time) internal returns (uint) { uint user_epoch = 0; uint to_distribute = 0; uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId); uint _start_time = start_time; if (max_user_epoch == 0) return 0; uint week_cursor = time_cursor_of[_tokenId]; if (week_cursor == 0) { user_epoch = _find_timestamp_user_epoch(ve, _tokenId, _start_time, max_user_epoch); } else { user_epoch = user_epoch_of[_tokenId]; } if (user_epoch == 0) user_epoch = 1; VotingEscrow.Point memory user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch); if (week_cursor == 0) week_cursor = (user_point.ts + WEEK - 1) / WEEK * WEEK; if (week_cursor >= last_token_time) return 0; if (week_cursor < _start_time) week_cursor = _start_time; VotingEscrow.Point memory old_user_point; for (uint i = 0; i < 50; i++) { if (week_cursor >= _last_token_time) break; if (week_cursor >= user_point.ts && user_epoch <= max_user_epoch) { user_epoch += 1; old_user_point = user_point; if (user_epoch > max_user_epoch) { user_point = VotingEscrow.Point(0,0,0,0); } else { user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch); } } else { int128 dt = int128(int256(week_cursor - old_user_point.ts)); uint balance_of = Math.max(uint(int256(old_user_point.bias - dt * old_user_point.slope)), 0); if (balance_of == 0 && user_epoch > max_user_epoch) break; if (balance_of > 0) { to_distribute += balance_of * tokens_per_week[week_cursor] / ve_supply[week_cursor]; } week_cursor += WEEK; } } user_epoch = Math.min(max_user_epoch, user_epoch - 1); user_epoch_of[_tokenId] = user_epoch; time_cursor_of[_tokenId] = week_cursor; emit Claimed(_tokenId, to_distribute, user_epoch, max_user_epoch); return to_distribute; } function _claimable(uint _tokenId, address ve, uint _last_token_time) internal view returns (uint) { uint user_epoch = 0; uint to_distribute = 0; uint max_user_epoch = VotingEscrow(ve).user_point_epoch(_tokenId); uint _start_time = start_time; if (max_user_epoch == 0) return 0; uint week_cursor = time_cursor_of[_tokenId]; if (week_cursor == 0) { user_epoch = _find_timestamp_user_epoch(ve, _tokenId, _start_time, max_user_epoch); } else { user_epoch = user_epoch_of[_tokenId]; } if (user_epoch == 0) user_epoch = 1; VotingEscrow.Point memory user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch); if (week_cursor == 0) week_cursor = (user_point.ts + WEEK - 1) / WEEK * WEEK; if (week_cursor >= last_token_time) return 0; if (week_cursor < _start_time) week_cursor = _start_time; VotingEscrow.Point memory old_user_point; for (uint i = 0; i < 50; i++) { if (week_cursor >= _last_token_time) break; if (week_cursor >= user_point.ts && user_epoch <= max_user_epoch) { user_epoch += 1; old_user_point = user_point; if (user_epoch > max_user_epoch) { user_point = VotingEscrow.Point(0,0,0,0); } else { user_point = VotingEscrow(ve).user_point_history(_tokenId, user_epoch); } } else { int128 dt = int128(int256(week_cursor - old_user_point.ts)); uint balance_of = Math.max(uint(int256(old_user_point.bias - dt * old_user_point.slope)), 0); if (balance_of == 0 && user_epoch > max_user_epoch) break; if (balance_of > 0) { to_distribute += balance_of * tokens_per_week[week_cursor] / ve_supply[week_cursor]; } week_cursor += WEEK; } } return to_distribute; } function claimable(uint _tokenId) external view returns (uint) { uint _last_token_time = last_token_time / WEEK * WEEK; return _claimable(_tokenId, voting_escrow, _last_token_time); } function claim(uint _tokenId) external returns (uint) { if (block.timestamp >= time_cursor) _checkpoint_total_supply(); uint _last_token_time = last_token_time; _last_token_time = _last_token_time / WEEK * WEEK; uint amount = _claim(_tokenId, voting_escrow, _last_token_time); if (amount != 0) { VotingEscrow(voting_escrow).deposit_for(_tokenId, amount); token_last_balance -= amount; } return amount; } function claim_many(uint[] memory _tokenIds) external returns (bool) { if (block.timestamp >= time_cursor) _checkpoint_total_supply(); uint _last_token_time = last_token_time; _last_token_time = _last_token_time / WEEK * WEEK; address _voting_escrow = voting_escrow; uint total = 0; for (uint i = 0; i < _tokenIds.length; i++) { uint _tokenId = _tokenIds[i]; if (_tokenId == 0) break; uint amount = _claim(_tokenId, _voting_escrow, _last_token_time); if (amount != 0) { VotingEscrow(_voting_escrow).deposit_for(_tokenId, amount); total += amount; } } if (total != 0) { token_last_balance -= total; } return true; } // Once off event on contract initialize function setDepositor(address _depositor) external { require(msg.sender == depositor); depositor = _depositor; } }
322,480
11,823
a363384f2245ef3d05291c3cd28a05592952cb432922cbb40ee75fd5fd080f50
19,376
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/71/71b4b21cbbf2e727bd8c0fe639d029c6eb9edc3f_GreenRewards.sol
4,776
18,165
// SPDX-License-Identifier: Unlicensed pragma solidity ^0.8.9; 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); } abstract contract Ownable { address internal owner; address private _previousOwner; uint256 private _lockTime; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor(address _owner) { owner = _owner; } modifier onlyOwner() { require(isOwner(msg.sender), "!OWNER"); _; } function isOwner(address account) public view returns (bool) { return account == owner; } function transferOwnership(address 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 Ownershiplock(uint256 time) public virtual onlyOwner { _previousOwner = owner; owner = address(0); _lockTime = block.timestamp + time; emit OwnershipTransferred(owner, address(0)); } function Ownershipunlock() 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; } } interface IDEXFactory { function createPair(address tokenA, address tokenB) external returns (address pair); } interface IDEXRouter { function factory() external pure returns (address); function WAVAX() external pure returns (address); function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityAVAX(address token, uint amountTokenDesired, uint amountTokenMin, uint amountAVAXMin, address to, uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity); function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable; function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; } contract GreenRewards is IBEP20, Ownable { // Events event AutoLiquify(uint256 amountAVAX, uint256 amountTokens); event SetFees(uint256 liquidityFee, uint256 marketingFee, uint256 reflectionFee, uint256 teamFee, uint256 totalFee); event SetSwapBackSettings(bool enabled, uint256 swapThreshold); event SetIsFeeExempt(address holder, bool enabled); event SetFeeReceivers(address marketingReceiver, address teamFeeReceiver); event StuckBalanceSent(uint256 amountAVAX, address recipient); event SetMaxTx(uint256 maxTX); event SetMaxWallet(uint256 maxWallet); event MarketingFunds(uint256 amountAVAX, address recipient); event TeamFunds(uint256 amountAVAX, address recipient); event CanTransferBeforeLaunch(address holder, bool exempt); event ForeignTokenTransfer(address tokenAddress, uint256 quantity); // Mappings mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private isFeeExempt; mapping (address => bool) private isTxLimitExempt; mapping (address => bool) private canAddLiquidityBeforeLaunch; // Supply uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1000 * 10**_decimals; uint256 private _rTotal = (MAX - (MAX % _tTotal)); // Max Wallet & TX Limits uint256 public _maxWalletSize = _tTotal / 10000 * 2; uint256 public _maxTX = _tTotal / 10000 * 1; // Basic Contract Info string constant _name = 'GreenRewards'; string constant _symbol = 'GRWD'; uint8 constant _decimals = 9; // Detailed Fees uint256 private _reflectionFee = 2; uint256 private _marketingFee = 8; uint256 private _liquidityFee = 0; uint256 private _teamFee = 0; uint256 private totalFees = _marketingFee + _reflectionFee + _liquidityFee + _teamFee; uint256 private contractFees = _marketingFee + _liquidityFee + _teamFee; uint256 private _previousReflectionFee = _reflectionFee; uint256 private _previousMarketingFee = _marketingFee; uint256 private _previousliquidityFee = _liquidityFee; uint256 private _previousteamFee = _teamFee; // Fee Receiver address private marketingFeeReceiver = 0xbdc13FDC2a4e94E7626d1dFf75DCF53F4dc5F060; address private teamFeeReceiver = 0xbdc13FDC2a4e94E7626d1dFf75DCF53F4dc5F060; IDEXRouter public router; address public pair; uint256 public launchedAt; bool public swapEnabled = true; uint256 public swapThreshold = _tTotal / 1000 * 1; // 0.1% bool inSwap; modifier swapping() { inSwap = true; _; inSwap = false; } constructor () Ownable(msg.sender) { router = IDEXRouter(0x60aE616a2155Ee3d9A68541Ba4544862310933d4); pair = IDEXFactory(router.factory()).createPair(address(this), router.WAVAX()); _allowances[address(this)][address(router)] = type(uint256).max; isFeeExempt[owner] = true; isTxLimitExempt[owner] = true; canAddLiquidityBeforeLaunch[owner] = true; _balances[msg.sender] = _rTotal; emit Transfer(address(0), msg.sender, _tTotal); } receive() external payable {} // Basic Functions function name() external pure override returns (string memory) { return _name; } function symbol() external pure override returns (string memory) { return _symbol; } function decimals() external pure override returns (uint8) { return _decimals; } function getOwner() external view override returns (address) { return owner; } function totalSupply() external view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { return tokenFromReflection(_balances[account]);} function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(msg.sender, recipient, amount); return true; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender]- (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 tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount / (currentRate); } // Internal Functions 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(!launched() && recipient == pair){ require(canAddLiquidityBeforeLaunch[sender]); launch(); } checkTxLimit(sender, amount); if (recipient != pair && recipient != owner) { require(isTxLimitExempt[recipient] || tokenFromReflection(_balances[recipient]) + amount <= _maxWalletSize, "Transfer amount exceeds the bag size."); } if(shouldSwapBack()){ swapBack(); } _tokenTransfer(sender,recipient,amount); } function _tokenTransfer(address sender, address recipient, uint256 amount) private { if(!shouldTakeFee(sender) || !shouldTakeFee(recipient)) removeAllFee(); _transferStandard(sender, recipient, amount); if(!shouldTakeFee(sender) || !shouldTakeFee(recipient)) restoreAllFee(); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rReflection, uint256 tTransferAmount, uint256 tFees) = _getValues(tAmount); _balances[sender] = _balances[sender] - (rAmount); _balances[recipient] = _balances[recipient] + (rTransferAmount); _takeFees(tFees, rReflection); emit Transfer(sender, recipient, tTransferAmount); } function _takeFees(uint256 tFees, uint256 rReflection) private { _rTotal = _rTotal - (rReflection); uint256 currentRate = _getRate(); uint256 rFees = tFees * (currentRate); _balances[address(this)] = _balances[address(this)] + (rFees); } function checkTxLimit(address sender, uint256 amount) internal view { require(amount <= _maxTX || isTxLimitExempt[sender], "TX Limit Exceeded"); } function removeAllFee() private { if(_reflectionFee == 0 && _marketingFee == 0 && _liquidityFee == 0) return; _previousReflectionFee = _reflectionFee; _previousMarketingFee = _marketingFee; _previousliquidityFee = _liquidityFee; _previousteamFee = _teamFee; _reflectionFee = 0; _marketingFee = 0; _liquidityFee = 0; _teamFee = 0; contractFees = _marketingFee + _liquidityFee + _teamFee; } function restoreAllFee() private { _reflectionFee = _previousReflectionFee; _teamFee = _previousteamFee; _marketingFee = _previousMarketingFee; _liquidityFee = _previousliquidityFee; contractFees = _marketingFee + _liquidityFee + _teamFee; } function shouldSwapBack() internal view returns (bool) { return msg.sender != pair && !inSwap && swapEnabled && _balances[address(this)] >= swapThreshold; } function shouldTakeFee(address sender) internal view returns (bool) { return !isFeeExempt[sender]; } function swapBack() internal swapping { uint256 contractTokenBalance = balanceOf(address(this)); uint256 amountToLiquify = contractTokenBalance * _liquidityFee / contractFees / (2); uint256 amountToSwap = contractTokenBalance - amountToLiquify; address[] memory path = new address[](2); path[0] = address(this); path[1] = router.WAVAX(); router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp); uint256 amountAVAX = address(this).balance; uint256 totalAVAXFee = contractFees - (_liquidityFee / (2)); uint256 amountAVAXLiquidity = amountAVAX * _liquidityFee / totalAVAXFee / (2); uint256 amountAVAXMarketing = amountAVAX * _marketingFee / totalAVAXFee; uint256 amountAVAXTeam = amountAVAX - amountAVAXMarketing - amountAVAXLiquidity; if(amountAVAXMarketing > 0) {payable(marketingFeeReceiver).transfer(amountAVAXMarketing); emit MarketingFunds(amountAVAXMarketing, marketingFeeReceiver); } if(amountAVAXTeam > 0) {payable(teamFeeReceiver).transfer(amountAVAXTeam); emit TeamFunds(amountAVAXTeam, teamFeeReceiver); } if(amountToLiquify > 0){ router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this), amountToLiquify, 0, 0, marketingFeeReceiver, block.timestamp); emit AutoLiquify(amountAVAXLiquidity, amountToLiquify); } } function launched() internal view returns (bool) { return launchedAt != 0; } function launch() internal { launchedAt = block.timestamp; } // Reflections code function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tReflection, uint256 tFees) = _calculateTokenValues(tAmount); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rReflection) = _calculateRateValues(tAmount, tReflection, tFees, currentRate); return (rAmount, rTransferAmount, rReflection, tTransferAmount, tFees); } function _calculateTokenValues(uint256 tAmount) private view returns (uint256, uint256, uint256) { uint256 feeAmount = tAmount * (totalFees) / 100; uint256 tReflection = feeAmount * (_reflectionFee) / totalFees; uint256 tFees = feeAmount * (contractFees) / totalFees; uint256 tTransferAmount = tAmount - tReflection - tFees; return (tTransferAmount, tReflection, tFees); } function _calculateRateValues(uint256 tAmount, uint256 tReflection, uint256 tFees, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount * (currentRate); uint256 rReflection = tReflection * (currentRate); uint256 rFees = tFees * (currentRate); uint256 rTransferAmount = rAmount - (rReflection) - (rFees); return (rAmount, rTransferAmount, rReflection); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply / (tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; if (rSupply < _rTotal / (_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } // External Functions function setIsFeeExempt(address holder, bool exempt) external onlyOwner { isFeeExempt[holder] = exempt; emit SetIsFeeExempt(holder, exempt); } function setFees(uint256 liquidityFee, uint256 marketingFee, uint256 reflectionFee, uint256 teamFee) external onlyOwner { require(liquidityFee + marketingFee + reflectionFee + teamFee < 33, "Total fees must be below 33%"); _liquidityFee = liquidityFee; _marketingFee = marketingFee; _reflectionFee = reflectionFee; _teamFee = teamFee; totalFees = _liquidityFee + _marketingFee + _reflectionFee + _teamFee; contractFees = _liquidityFee + _marketingFee + _teamFee; emit SetFees(_liquidityFee, _marketingFee, _reflectionFee, _teamFee, totalFees); } function setFeeReceiver(address _marketingFeeReceiver, address _teamFeeReceiver) external onlyOwner { marketingFeeReceiver = _marketingFeeReceiver; teamFeeReceiver = _teamFeeReceiver; emit SetFeeReceivers(marketingFeeReceiver, teamFeeReceiver); } function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner { require(_amount > 0, "Can't set SwapThreshold to ZERO"); swapEnabled = _enabled; swapThreshold = _amount; emit SetSwapBackSettings(swapEnabled, swapThreshold); } function setMaxTx(uint256 maxTX) external onlyOwner { require(maxTX > _tTotal / 1000, "Can't set maxTX below 0.1%"); _maxTX = maxTX; emit SetMaxTx(maxTX); } function setMaxWallet(uint256 maxWallet) external onlyOwner { require(maxWallet > _tTotal / 1000, "Can't set maxTX below 0.1%"); _maxWalletSize = maxWallet; emit SetMaxWallet(maxWallet); } function setCanTransferBeforeLaunch(address holder, bool exempt) external onlyOwner { canAddLiquidityBeforeLaunch[holder] = exempt; //Presale Address will be added as Exempt isFeeExempt[holder] = exempt; isTxLimitExempt[holder] = exempt; emit CanTransferBeforeLaunch(holder, exempt); } // Stuck Balance Functions function ClearStuckBalance() external onlyOwner { uint256 contractBalance = address(this).balance; payable(marketingFeeReceiver).transfer(contractBalance); emit StuckBalanceSent(contractBalance, marketingFeeReceiver); } function transferForeignToken(address _token) public onlyOwner { uint256 _contractBalance = IBEP20(_token).balanceOf(address(this)); payable(marketingFeeReceiver).transfer(_contractBalance); emit ForeignTokenTransfer(_token, _contractBalance); } }
80,921
11,824
00996a577afbf7b30379944c34ed097cfd9b3cc39e23542391b0daa79a1e6b2a
17,565
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TN/TNiTHVApr4Y6gsGsy4yttWSPGbia4e1bqN_USCToken.sol
3,220
11,983
//SourceUnit: USCToken.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 USCToken is Context, ITRC20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; string private _name = 'USCToken'; string private _symbol = 'USC'; uint8 private _decimals = 6; uint256 private _totalSupply = 19131 * 10**uint256(_decimals); address private _burnPool = address(0); address private _fundAddress; uint256 public _burnFee = 3; 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 = 4913 * 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; event SwapAndLiquifyEnabledUpdated(bool enabled); event SwapAndLiquify(uint256 tokensSwapped, uint256 trxReceived, uint256 tokensIntoLiqudity); event InitLiquidity(uint256 tokensAmount, uint256 trxAmount, uint256 liqudityAmount); modifier lockTheSwap { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } constructor (address fundAddress) public { _fundAddress = fundAddress; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _balances[_msgSender()] = _totalSupply; emit Transfer(address(0), _msgSender(), _totalSupply); } receive () external payable {} function name() public view virtual returns (string memory) { return _name; } function symbol() public view virtual returns (string memory) { return _symbol; } function decimals() public view virtual returns (uint8) { return _decimals; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _approve(sender, _msgSender(), currentAllowance - amount); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); _approve(_msgSender(), spender, currentAllowance - subtractedValue); return true; } function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner { swapAndLiquifyEnabled = _enabled; emit SwapAndLiquifyEnabledUpdated(_enabled); } function setMaxStopFeeTotal(uint256 total) public onlyOwner { MAX_STOP_FEE_TOTAL = total; restoreAllFee(); } function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function setExchangePool(address exchangePool) public onlyOwner { _exchangePool = exchangePool; } function totalBurnFee() public view returns (uint256) { return _burnFeeTotal; } function totalFundFee() public view returns (uint256) { return _fundFeeTotal; } function totalLiquidityFee() public view returns (uint256) { return _liquidityFeeTotal; } function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); if (_totalSupply <= MAX_STOP_FEE_TOTAL) { removeAllFee(); _transferStandard(sender, recipient, amount); } else { if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient] || recipient == _exchangePool) { removeAllFee(); } _transferStandard(sender, recipient, amount); if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient] || recipient == _exchangePool) { restoreAllFee(); } } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount); _balances[sender] = _balances[sender].sub(tAmount); _balances[recipient] = _balances[recipient].add(tTransferAmount); if(!_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient] && recipient != _exchangePool) { _balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity); _liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity); _balances[_fundAddress] = _balances[_fundAddress].add(tFund); _fundFeeTotal = _fundFeeTotal.add(tFund); _totalSupply = _totalSupply.sub(tBurn); _burnFeeTotal = _burnFeeTotal.add(tBurn); emit Transfer(sender, _exchangePool, tLiquidity); emit Transfer(sender, _fundAddress, tFund); emit Transfer(sender, _burnPool, tBurn); } emit Transfer(sender, recipient, tTransferAmount); } function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function calculateBurnFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_burnFee).div(10**2); } function calculateLiquidityFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_liquidityFee).div(10 ** 2); } function calculateFundFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_fundFee).div(10 ** 2); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount); return (tTransferAmount, tBurn, tLiquidity, tFund); } function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) { uint256 tBurn = calculateBurnFee(tAmount); uint256 tLiquidity = calculateLiquidityFee(tAmount); uint256 tFund = calculateFundFee(tAmount); uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund); return (tTransferAmount, tBurn, tLiquidity, tFund); } function removeAllFee() private { if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return; _previousLiquidityFee = _liquidityFee; _previousBurnFee = _burnFee; _previousFundFee = _fundFee; _liquidityFee = 0; _burnFee = 0; _fundFee = 0; } function restoreAllFee() private { _liquidityFee = _previousLiquidityFee; _burnFee = _previousBurnFee; _fundFee = _previousFundFee; } }
306,326
11,825
bdb2317616bc71e0c28f846d61c7346bb7df42cc7aedae1c72154b18d0b929b2
15,952
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xe8940b7d6f17f24583894f807bc2764aa635d36b.sol
4,289
15,751
pragma solidity ^0.4.23; library SafeMathLib { 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 DateTimeLib { struct _DateTime { uint16 year; uint8 month; uint8 day; uint8 hour; uint8 minute; uint8 second; uint8 weekday; } uint constant DAY_IN_SECONDS = 86400; uint constant YEAR_IN_SECONDS = 31536000; uint constant LEAP_YEAR_IN_SECONDS = 31622400; uint constant HOUR_IN_SECONDS = 3600; uint constant MINUTE_IN_SECONDS = 60; uint16 constant ORIGIN_YEAR = 1970; function isLeapYear(uint16 year) internal pure returns (bool) { if (year % 4 != 0) { return false; } if (year % 100 != 0) { return true; } if (year % 400 != 0) { return false; } return true; } function leapYearsBefore(uint year) internal pure returns (uint) { year -= 1; return year / 4 - year / 100 + year / 400; } function getDaysInMonth(uint8 month, uint16 year) internal pure returns (uint8) { if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) { return 31; } else if (month == 4 || month == 6 || month == 9 || month == 11) { return 30; } else if (isLeapYear(year)) { return 29; } else { return 28; } } function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) { uint secondsAccountedFor = 0; uint buf; uint8 i; dt.year = getYear(timestamp); buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR); secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf; secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf); uint secondsInMonth; for (i = 1; i <= 12; i++) { secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year); if (secondsInMonth + secondsAccountedFor > timestamp) { dt.month = i; break; } secondsAccountedFor += secondsInMonth; } for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) { if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) { dt.day = i; break; } secondsAccountedFor += DAY_IN_SECONDS; } dt.hour = getHour(timestamp); dt.minute = getMinute(timestamp); dt.second = getSecond(timestamp); dt.weekday = getWeekday(timestamp); } function getYear(uint timestamp) internal pure returns (uint16) { uint secondsAccountedFor = 0; uint16 year; uint numLeapYears; year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS); numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR); secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears; secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears); while (secondsAccountedFor > timestamp) { if (isLeapYear(uint16(year - 1))) { secondsAccountedFor -= LEAP_YEAR_IN_SECONDS; } else { secondsAccountedFor -= YEAR_IN_SECONDS; } year -= 1; } return year; } function getMonth(uint timestamp) internal pure returns (uint8) { return parseTimestamp(timestamp).month; } function getDay(uint timestamp) internal pure returns (uint8) { return parseTimestamp(timestamp).day; } function getHour(uint timestamp) internal pure returns (uint8) { return uint8((timestamp / 60 / 60) % 24); } function getMinute(uint timestamp) internal pure returns (uint8) { return uint8((timestamp / 60) % 60); } function getSecond(uint timestamp) internal pure returns (uint8) { return uint8(timestamp % 60); } function getWeekday(uint timestamp) internal pure returns (uint8) { return uint8((timestamp / DAY_IN_SECONDS + 4) % 7); } function toTimestamp(uint16 year, uint8 month, uint8 day) internal pure returns (uint timestamp) { return toTimestamp(year, month, day, 0, 0, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) internal pure returns (uint timestamp) { return toTimestamp(year, month, day, hour, 0, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) internal pure returns (uint timestamp) { return toTimestamp(year, month, day, hour, minute, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) internal pure returns (uint timestamp) { uint16 i; for (i = ORIGIN_YEAR; i < year; i++) { if (isLeapYear(i)) { timestamp += LEAP_YEAR_IN_SECONDS; } else { timestamp += YEAR_IN_SECONDS; } } uint8[12] memory monthDayCounts; monthDayCounts[0] = 31; if (isLeapYear(year)) { monthDayCounts[1] = 29; } else { monthDayCounts[1] = 28; } monthDayCounts[2] = 31; monthDayCounts[3] = 30; monthDayCounts[4] = 31; monthDayCounts[5] = 30; monthDayCounts[6] = 31; monthDayCounts[7] = 31; monthDayCounts[8] = 30; monthDayCounts[9] = 31; monthDayCounts[10] = 30; monthDayCounts[11] = 31; for (i = 1; i < month; i++) { timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1]; } timestamp += DAY_IN_SECONDS * (day - 1); timestamp += HOUR_IN_SECONDS * (hour); timestamp += MINUTE_IN_SECONDS * (minute); timestamp += second; return timestamp; } } interface IERC20 { function totalSupply() external constant returns (uint256); function balanceOf(address _owner) external constant returns (uint256 balance); function transfer(address _to, uint256 _value) external returns (bool success); function transferFrom(address _from, address _to, uint256 _value) external returns (bool success); function approve(address _spender, uint256 _value) external returns (bool success); function allowance(address _owner, address _spender) external constant returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address _spender, uint256 _value); } contract StandardToken is IERC20,DateTimeLib { using SafeMathLib for uint256; mapping(address => uint256) balances; mapping(address => mapping(address => uint256)) allowed; string public constant symbol = "JCB"; string public constant name = "JoinCoin"; uint _totalSupply = 1000000000 * 10 ** 8; uint8 public constant decimals = 8; function totalSupply() external constant returns (uint256) { return _totalSupply; } function balanceOf(address _owner) external constant returns (uint256 balance) { return balances[_owner]; } function transfer(address _to, uint256 _value) public returns (bool success) { return transferInternal(msg.sender, _to, _value); } function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) { require(_value > 0 && balances[_from] >= _value); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value > 0 && allowed[_from][msg.sender] >= _value && balances[_from] >= _value); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract LockableToken is StandardToken { address internal developerReservedAddress = 0xf4ab0e0269E05163E65608F44E80A125A511a916; uint[4] internal developerReservedUnlockTimes; uint256[4] internal developerReservedBalanceLimits; function getDeveloperReservedBalanceLimit() internal returns (uint256 balanceLimit) { uint time = now; for (uint index = 0; index < developerReservedUnlockTimes.length; index++) { if (developerReservedUnlockTimes[index] == 0x0) { continue; } if (time > developerReservedUnlockTimes[index]) { developerReservedUnlockTimes[index] = 0x0; } else { return developerReservedBalanceLimits[index]; } } return 0; } function transfer(address _to, uint256 _value) public returns (bool success) { return transferInternal(msg.sender, _to, _value); } function transferInternal(address _from, address _to, uint256 _value) internal returns (bool success) { require(_from != 0x0 && _to != 0x0 && _value > 0x0); if (_from == developerReservedAddress) { uint256 balanceLimit = getDeveloperReservedBalanceLimit(); require(balances[_from].sub(balanceLimit) >= _value); } return super.transferInternal(_from, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_from != 0x0 && _to != 0x0 && _value > 0x0); if (_from == developerReservedAddress) { uint256 balanceLimit = getDeveloperReservedBalanceLimit(); require(balances[_from].sub(balanceLimit) >= _value); } return super.transferFrom(_from, _to, _value); } event UnlockTimeChanged(uint index, uint unlockTime, uint newUnlockTime); event LockInfo(address indexed publicOfferingAddress, uint index, uint unlockTime, uint256 balanceLimit); } contract TradeableToken is LockableToken { address internal publicOfferingAddress = 0xbdB45923Bf511801F71EAeD4fbd926E48bA43DB5; uint256 public exchangeRate = 4000; function buy(address _beneficiary, uint256 _weiAmount) internal { require(_beneficiary != 0x0); require(publicOfferingAddress != 0x0); require(exchangeRate > 0x0); require(_weiAmount > 0x0); uint256 exchangeToken = _weiAmount.mul(exchangeRate); exchangeToken = exchangeToken.div(1 * 10 ** 10); publicOfferingAddress.transfer(_weiAmount); super.transferInternal(publicOfferingAddress, _beneficiary, exchangeToken); } event ExchangeRateChanged(uint256 oldExchangeRate,uint256 newExchangeRate); } contract OwnableToken is TradeableToken { address internal owner = 0xfe71ea94aD48c03a8B1D5c8A371E36Fc0E05856A; mapping(address => uint) administrators; modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyAdministrator() { require(msg.sender == owner || administrators[msg.sender] > 0x0); _; } function transferOwnership(address _newOwner) onlyOwner public { require(_newOwner != address(0)); owner = _newOwner; emit OwnershipTransferred(owner, _newOwner); } function addAdministrator(address _adminAddress) onlyOwner public { require(_adminAddress != address(0)); require(administrators[_adminAddress] <= 0x0); administrators[_adminAddress] = 0x1; emit AddAdministrator(_adminAddress); } function removeAdministrator(address _adminAddress) onlyOwner public { require(_adminAddress != address(0)); require(administrators[_adminAddress] > 0x0); administrators[_adminAddress] = 0x0; emit RemoveAdministrator(_adminAddress); } function setExchangeRate(uint256 _exchangeRate) public onlyAdministrator returns (bool success) { require(_exchangeRate > 0x0); uint256 oldExchangeRate = exchangeRate; exchangeRate = _exchangeRate; emit ExchangeRateChanged(oldExchangeRate, exchangeRate); return true; } function changeUnlockTime(uint _index, uint _unlockTime) public onlyAdministrator returns (bool success) { require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _unlockTime > 0x0); if(_index > 0x0) { uint beforeUnlockTime = developerReservedUnlockTimes[_index - 1]; require(beforeUnlockTime == 0x0 || beforeUnlockTime < _unlockTime); } if(_index < developerReservedUnlockTimes.length - 1) { uint afterUnlockTime = developerReservedUnlockTimes[_index + 1]; require(afterUnlockTime == 0x0 || _unlockTime < afterUnlockTime); } uint oldUnlockTime = developerReservedUnlockTimes[_index]; developerReservedUnlockTimes[_index] = _unlockTime; emit UnlockTimeChanged(_index,oldUnlockTime,_unlockTime); return true; } function getDeveloperReservedLockInfo(uint _index) public onlyAdministrator returns (uint, uint256) { require(_index >= 0x0 && _index < developerReservedUnlockTimes.length && _index < developerReservedBalanceLimits.length); emit LockInfo(developerReservedAddress,_index,developerReservedUnlockTimes[_index],developerReservedBalanceLimits[_index]); return (developerReservedUnlockTimes[_index], developerReservedBalanceLimits[_index]); } event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); event AddAdministrator(address indexed adminAddress); event RemoveAdministrator(address indexed adminAddress); } contract JCB is OwnableToken { function JCB() public { balances[owner] = 500000000 * 10 ** 8; balances[publicOfferingAddress] = 300000000 * 10 ** 8; uint256 developerReservedBalance = 200000000 * 10 ** 8; balances[developerReservedAddress] = developerReservedBalance; developerReservedUnlockTimes = [ DateTimeLib.toTimestamp(2019, 7, 1), DateTimeLib.toTimestamp(2020, 7, 1), DateTimeLib.toTimestamp(2021, 7, 1), DateTimeLib.toTimestamp(2022, 7, 1) ]; developerReservedBalanceLimits = [ developerReservedBalance, developerReservedBalance - (developerReservedBalance / 4) * 1, developerReservedBalance - (developerReservedBalance / 4) * 2, developerReservedBalance - (developerReservedBalance / 4) * 3 ]; } function() public payable { buy(msg.sender, msg.value); } }
208,021
11,826
951e92a1950c4f5fc6617b87943fc39b34cdd88da21592153be9eaa8d799cd07
29,441
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/33/337e2c10235d4DC4dd6E38e1c6B25859DEf53F93_WATER.sol
5,179
18,685
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 WATER 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 = 70000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'Fire Dao'; string private constant _symbol = 'WATER'; uint256 private _taxFee = 400; uint256 private _burnFee = 0; uint public max_tx_size = 70000 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 != 0x143b92CD8BDb4F7A196D9D39310EE951eDe40C17, '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; } }
311,474
11,827
4915be0c7562dd2098be52c2cd98f2831f6540c132bb916db93a48c94b686a92
16,181
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x65507341fb08124920f2c12e91fb0b922093932c.sol
3,885
15,192
pragma solidity 0.4.18; // File: contracts/ERC20Interface.sol // https://github.com/ethereum/EIPs/issues/20 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); } // File: contracts/KyberReserveInterface.sol /// @title Kyber Reserve contract 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); } // File: contracts/Utils.sol /// @title Kyber constants contract 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 } } // File: contracts/Utils2.sol contract Utils2 is Utils { /// @dev get the balance of a user. /// @param token The token type /// @return The balance function getBalance(ERC20 token, address user) public view returns(uint) { if (token == ETH_TOKEN_ADDRESS) return user.balance; else return token.balanceOf(user); } function getDecimalsSafe(ERC20 token) internal returns(uint) { if (decimals[token] == 0) { setDecimals(token); } return decimals[token]; } function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) { return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate); } function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) { return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate); } function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals) internal pure returns(uint) { require(srcAmount <= MAX_QTY); require(destAmount <= MAX_QTY); if (dstDecimals >= srcDecimals) { require((dstDecimals - srcDecimals) <= MAX_DECIMALS); return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount)); } else { require((srcDecimals - dstDecimals) <= MAX_DECIMALS); return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount); } } } // File: contracts/PermissionGroups.sol 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; } } } } // File: contracts/Withdrawable.sol 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); } } // File: contracts/oasisContracts/KyberBancorReserve.sol contract IBancorConverter { function getReturn(ERC20 _fromToken, ERC20 _toToken, uint _amount) public view returns (uint256, uint256); } contract KyberBancorReserve is KyberReserveInterface, Withdrawable, Utils2 { address public sanityRatesContract = 0; address public kyberNetwork; IBancorConverter public bancor; ERC20 public token; ERC20 public constant BANCOR_ETH = ERC20(0xc0829421C1d260BD3cB3E0F06cfE2D52db2cE315); bool public tradeEnabled = true; int public buyPremiumInBps = -25; int public sellPremiumInBps = -25; uint public lastBuyRate; uint public lastSellRate; uint public baseEthQty = 5 ether; function KyberBancorReserve(IBancorConverter _bancor, address _kyberNetwork, ERC20 _token, address _admin) public { require(_bancor != address(0)); require(_kyberNetwork != address(0)); require(_token != address(0)); kyberNetwork = _kyberNetwork; bancor = _bancor; token = _token; admin = _admin; setDecimals(token); setDecimals(ETH_TOKEN_ADDRESS); } function() public payable { // anyone can deposit ether } function setPremium(int newBuyPremium, int newSellPremium, uint newEthBaseQty) public onlyAdmin { require(newBuyPremium >= -10000); require(newBuyPremium <= int(MAX_QTY)); require(newSellPremium >= -10000); require(newSellPremium <= int(MAX_QTY)); sellPremiumInBps = newSellPremium; buyPremiumInBps = newBuyPremium; baseEthQty = newEthBaseQty; } event TradeExecute(address indexed sender, 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 KyberNetworkSet(address kyberNetwork); function setKyberNetwork(address _kyberNetwork) public onlyAdmin { require(_kyberNetwork != address(0)); kyberNetwork = _kyberNetwork; KyberNetworkSet(kyberNetwork); } function valueAfterAddingPremium(uint val, int premiumInBps) public pure returns(uint) { require(val <= MAX_QTY); return val * uint(10000 + premiumInBps) / 10000; } function shouldUseInternalInventory(uint val, ERC20 dest) public view returns(bool) { if (dest == token) { return val <= token.balanceOf(this); } else { return val <= this.balance; } } function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) { srcQty; blockNumber; if (!tradeEnabled) return 0; if (!validTokens(src, dest)) return 0; if (src == ETH_TOKEN_ADDRESS) return lastBuyRate; else return lastSellRate; } function getBancorRatePlusPremiumForEthQty(uint ethQty) public view returns(uint, uint) { uint tokenReturn; uint ethReturn; uint buyRate = 0; uint sellRate = 0; if (!tradeEnabled) return (0,0); (tokenReturn,) = bancor.getReturn(BANCOR_ETH, token, ethQty); (ethReturn,) = bancor.getReturn(token, BANCOR_ETH, tokenReturn); tokenReturn = valueAfterAddingPremium(tokenReturn, buyPremiumInBps); ethReturn = valueAfterAddingPremium(ethReturn, sellPremiumInBps); if(! shouldUseInternalInventory(tokenReturn,token)) tokenReturn = 0; if(! shouldUseInternalInventory(ethReturn,ETH_TOKEN_ADDRESS)) ethReturn = 0; if(tokenReturn > 0) buyRate = calcRateFromQty(ethQty, tokenReturn, getDecimals(ETH_TOKEN_ADDRESS), getDecimals(token)); if(ethReturn > 0) sellRate = calcRateFromQty(tokenReturn, ethReturn, getDecimals(token), getDecimals(ETH_TOKEN_ADDRESS)); return (buyRate,sellRate); } function doTrade(ERC20 srcToken, uint srcAmount, ERC20 destToken, address destAddress, uint conversionRate, bool validate) internal returns(bool) { require(validTokens(srcToken, destToken)); // 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); } if (srcToken != ETH_TOKEN_ADDRESS) require(token.transferFrom(msg.sender,this,srcAmount)); uint userExpectedDestAmount = calcDstQty(srcAmount, getDecimals(srcToken), getDecimals(destToken), conversionRate); if(destToken == ETH_TOKEN_ADDRESS) destAddress.transfer(userExpectedDestAmount); else require(destToken.transfer(destAddress, userExpectedDestAmount)); TradeExecute(msg.sender, srcToken, srcAmount, destToken, userExpectedDestAmount, destAddress); (lastBuyRate, lastSellRate) = getBancorRatePlusPremiumForEthQty(baseEthQty); return true; } function validTokens(ERC20 src, ERC20 dest) internal view returns (bool valid) { return ((token == src && ETH_TOKEN_ADDRESS == dest) || (token == dest && ETH_TOKEN_ADDRESS == src)); } }
198,122
11,828
34c273c2810605e9a3d64e5068148da8485e14b8c85434e57cfbe9a239ebc9e5
22,189
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/7d/7d2040e4eeed5c9046993e9ffd581404f943652f_VestingWallet.sol
2,563
10,594
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (finance/VestingWallet.sol) pragma solidity ^0.8.0; interface IERC20 { function totalSupply() external view returns (uint256); function owner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success,) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeERC20 { using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function _callOptionalReturn(IERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } 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 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. return (a & b) + (a ^ b) / 2; } function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a / b + (a % b == 0 ? 0 : 1); } function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } } contract VestingWallet is Context { event EtherReleased(uint256 amount); event ERC20Released(address indexed token, uint256 amount); uint256 private _released; mapping(address => uint256) private _erc20Released; address private _beneficiary; uint64 private immutable _start; uint64 private immutable _duration; constructor(address beneficiaryAddress, uint64 startTimestamp, uint64 durationSeconds) { require(beneficiaryAddress != address(0), "VestingWallet: beneficiary is zero address"); _beneficiary = beneficiaryAddress; _start = startTimestamp; _duration = durationSeconds; } receive() external payable virtual {} function beneficiary() public view virtual returns (address) { return _beneficiary; } function changeBeneficiary(address newBeneficiary) public virtual{ require(msg.sender == _beneficiary, "ECR20: Only current beneficiary can change beneficiaries"); _beneficiary = newBeneficiary; } function start() public view virtual returns (uint256) { return _start; } function duration() public view virtual returns (uint256) { return _duration; } function released() public view virtual returns (uint256) { return _released; } function released(address token) public view virtual returns (uint256) { return _erc20Released[token]; } function release() public virtual { uint256 releasable = vestedAmount(uint64(block.timestamp)) - released(); _released += releasable; emit EtherReleased(releasable); Address.sendValue(payable(beneficiary()), releasable); } function release(address token) public virtual { uint256 releasable = vestedAmount(token, uint64(block.timestamp)) - released(token); _erc20Released[token] += releasable; emit ERC20Released(token, releasable); SafeERC20.safeTransfer(IERC20(token), beneficiary(), releasable); } function vestedAmount(uint64 timestamp) public view virtual returns (uint256) { return _vestingSchedule(address(this).balance + released(), timestamp); } function vestedAmount(address token, uint64 timestamp) public view virtual returns (uint256) { return _vestingSchedule(IERC20(token).balanceOf(address(this)) + released(token), timestamp); } function _vestingSchedule(uint256 totalAllocation, uint64 timestamp) internal view virtual returns (uint256) { if (timestamp < start()) { return 0; } else if (timestamp > start() + duration()) { return totalAllocation; } else { return (totalAllocation * (timestamp - start())) / duration(); } } }
74,533
11,829
21b14ee4b41603c11923cca379806d285f0fd88ae9b9a67d1041e60f40055766
27,427
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/e4/E4809Ed214631017737A3d7FA3e78600Ee96Eb85_AvaxProxy.sol
2,847
12,032
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; abstract contract Proxy { function _delegate(address implementation) internal virtual { assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } function _implementation() internal view virtual returns (address); function _fallback() internal virtual { _beforeFallback(); _delegate(_implementation()); } fallback() external payable virtual { _fallback(); } receive() external payable virtual { _fallback(); } function _beforeFallback() internal virtual {} } interface IBeacon { function implementation() external view returns (address); } 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 StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly { r.slot := slot } } function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly { r.slot := slot } } function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly { r.slot := slot } } function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly { r.slot := slot } } } abstract contract ERC1967Upgrade { // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; event Upgraded(address indexed implementation); function _getImplementation() internal view returns (address) { return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; } function _setImplementation(address newImplementation) private { require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal { _upgradeTo(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } } function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal { address oldImplementation = _getImplementation(); // Initial upgrade and setup call _setImplementation(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } // Perform rollback test if not already in progress StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT); if (!rollbackTesting.value) { // Trigger rollback using upgradeTo from the new implementation rollbackTesting.value = true; Address.functionDelegateCall(newImplementation, abi.encodeWithSignature("upgradeTo(address)", oldImplementation)); rollbackTesting.value = false; // Check rollback was effective require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades"); // Finally reset to the new implementation and log the upgrade _upgradeTo(newImplementation); } } bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; event AdminChanged(address previousAdmin, address newAdmin); function _getAdmin() internal view returns (address) { return StorageSlot.getAddressSlot(_ADMIN_SLOT).value; } function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; event BeaconUpgraded(address indexed beacon); function _getBeacon() internal view returns (address) { return StorageSlot.getAddressSlot(_BEACON_SLOT).value; } function _setBeacon(address newBeacon) private { require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require(Address.isContract(IBeacon(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract"); StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon; } function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); } } } contract ERC1967Proxy is Proxy, ERC1967Upgrade { constructor(address _logic, bytes memory _data) payable { assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)); _upgradeToAndCall(_logic, _data, false); } function _implementation() internal view virtual override returns (address impl) { return ERC1967Upgrade._getImplementation(); } } contract TransparentUpgradeableProxy is ERC1967Proxy { constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) { assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1)); _changeAdmin(admin_); } modifier ifAdmin() { if (msg.sender == _getAdmin()) { _; } else { _fallback(); } } function admin() external ifAdmin returns (address admin_) { admin_ = _getAdmin(); } function implementation() external ifAdmin returns (address implementation_) { implementation_ = _implementation(); } function changeAdmin(address newAdmin) external virtual ifAdmin { _changeAdmin(newAdmin); } function upgradeTo(address newImplementation) external ifAdmin { _upgradeToAndCall(newImplementation, bytes(""), false); } function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin { _upgradeToAndCall(newImplementation, data, true); } function _admin() internal view virtual returns (address) { return _getAdmin(); } function _beforeFallback() internal virtual override { require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target"); super._beforeFallback(); } } contract AvaxProxy is TransparentUpgradeableProxy { constructor(address logic, address admin, bytes memory data) TransparentUpgradeableProxy(logic, admin, data) {} }
94,861
11,830
1a9b3d4c0d08bd60fd96fd84ffd8b5069957eddb66714c5dedc92d8613c99226
12,566
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x2eee31223b1d043e6b63da8360b682e3fd2ebfbe.sol
3,276
11,861
pragma solidity ^0.4.25; contract EtherMiner{ 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 = "EtherMiner"; string public symbol = "ETM"; uint8 constant public decimals = 18; uint8 constant internal entryFee_ = 15; uint8 constant internal transferFee_ = 1; uint8 constant internal exitFee_ = 25; uint8 constant internal refferalFee_ = 30; uint256 constant internal tokenPriceInitial_ = 0.00000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.0000001 ether; uint256 constant internal magnitude = 2 ** 64; uint256 public stakingRequirement = 50e18; mapping(address => uint256) internal tokenBalanceLedger_; mapping(address => uint256) internal referralBalance_; mapping(address => int256) internal payoutsTo_; uint256 internal tokenSupply_; uint256 internal profitPerShare_; function buy(address _referredBy) public payable returns (uint256) { purchaseTokens(msg.value, _referredBy); } function() payable public { purchaseTokens(msg.value, 0x0); } function reinvest() onlyStronghands public { uint256 _dividends = myDividends(false); address _customerAddress = msg.sender; payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; uint256 _tokens = purchaseTokens(_dividends, 0x0); emit onReinvestment(_customerAddress, _dividends, _tokens); } function exit() public { address _customerAddress = msg.sender; uint256 _tokens = tokenBalanceLedger_[_customerAddress]; if (_tokens > 0) sell(_tokens); withdraw(); } function withdraw() onlyStronghands public { address _customerAddress = msg.sender; uint256 _dividends = myDividends(false); payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; _customerAddress.transfer(_dividends); emit onWithdraw(_customerAddress, _dividends); } function sell(uint256 _amountOfTokens) onlyBagholders public { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); uint256 _tokens = _amountOfTokens; uint256 _ethereum = tokensToEthereum_(_tokens); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens); int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude)); payoutsTo_[_customerAddress] -= _updatedPayouts; if (tokenSupply_ > 0) { profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); } emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice()); } function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); if (myDividends(true) > 0) { withdraw(); } uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100); uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee); uint256 _dividends = tokensToEthereum_(_tokenFee); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens); tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens); payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens); payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens); profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); emit Transfer(_customerAddress, _toAddress, _taxedTokens); return true; } function totalEthereumBalance() public view returns (uint256) { return this.balance; } function totalSupply() public view returns (uint256) { return tokenSupply_; } function myTokens() public view returns (uint256) { address _customerAddress = msg.sender; return balanceOf(_customerAddress); } function myDividends(bool _includeReferralBonus) public view returns (uint256) { address _customerAddress = msg.sender; return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ; } function balanceOf(address _customerAddress) public view returns (uint256) { return tokenBalanceLedger_[_customerAddress]; } function dividendsOf(address _customerAddress) public view returns (uint256) { return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude; } function sellPrice() public view returns (uint256) { // our calculation relies on the token supply, so we need supply. Doh. if (tokenSupply_ == 0) { return tokenPriceInitial_ - tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } } function buyPrice() public view returns (uint256) { if (tokenSupply_ == 0) { return tokenPriceInitial_ + tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100); uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends); return _taxedEthereum; } } function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) { uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); return _amountOfTokens; } function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) { require(_tokensToSell <= tokenSupply_); uint256 _ethereum = tokensToEthereum_(_tokensToSell); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) { address _customerAddress = msg.sender; uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100); uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100); uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus); uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); uint256 _fee = _dividends * magnitude; require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_); if (_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != _customerAddress && tokenBalanceLedger_[_referredBy] >= stakingRequirement) { referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus); } else { _dividends = SafeMath.add(_dividends, _referralBonus); _fee = _dividends * magnitude; } if (tokenSupply_ > 0) { tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens); profitPerShare_ += (_dividends * magnitude / tokenSupply_); _fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_))); } else { tokenSupply_ = _amountOfTokens; } tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens); int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee); payoutsTo_[_customerAddress] += _updatedPayouts; emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice()); return _amountOfTokens; } function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) { uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18; uint256 _tokensReceived = ((SafeMath.sub((sqrt ((_tokenPriceInitial ** 2) + (2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18)) + ((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2)) + (2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_); return _tokensReceived; } function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) { uint256 tokens_ = (_tokens + 1e18); uint256 _tokenSupply = (tokenSupply_ + 1e18); uint256 _etherReceived = (SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2) / 1e18); return _etherReceived; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = (x + 1) / 2; y = x; while (z < y) { y = z; z = (x / z + z) / 2; } } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
216,025
11,831
081782a7285b1c7e71f021896a6973687b8e50a02eea36f8165c8a09a50a2122
16,895
.sol
Solidity
false
606585904
plotchy/defi-detective
f48830b1085dac002283a2ce5e565e341aab5d0c
00byaddress/00b05ff05065c1dd6fcced1c6b375a63497a7d58.sol
3,315
13,529
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; //pragma experimental ABIEncoderV2; contract SafeMath { function safeMul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function safeDiv(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 safeSub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function safeAdd(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } //------------------------------------------------------------------------------------- abstract contract ERC20 { uint public totalSupply; function balanceOf(address who) public virtual view returns (uint); function allowance(address owner, address spender) public virtual view returns (uint); function transfer(address to, uint value) public virtual returns (bool ok); function transferFrom(address from, address to, uint value) public virtual returns (bool ok); function approve(address spender, uint value) public virtual returns (bool ok); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } abstract contract ERC223 is ERC20 { function transfer(address to, uint value, bytes memory data) public virtual returns (bool ok); function transferFrom(address from, address to, uint value, bytes memory data) public virtual returns (bool ok); } abstract contract ERC223Receiver { function tokenFallback(address _sender, address _origin, uint _value, bytes memory _data) public virtual returns (bool ok); } abstract contract Standard223Receiver is ERC223Receiver { function supportsToken(address token) public virtual view returns (bool); } //------------------------------------------------------------------------------------- //Implementation contract MetaMediaToken223Token_15 is ERC20, ERC223, Standard223Receiver, SafeMath { mapping(address => uint) balances; mapping (address => mapping (address => uint)) allowed; string public name; //fancy name: eg Simon Bucks uint8 public decimals; //How many decimals to show. string public symbol; //An identifier: eg SBX address contrInitiator; address thisContract; bool isTokenSupport; mapping(address => bool) isSendingLocked; bool isAllTransfersLocked; uint oneTransferLimit; uint oneDayTransferLimit; struct TransferInfo { //address sender; //maybe use in the future //address from; //no need because all this is kept in transferInfo[_from] //address to; //maybe use in the future uint256 value; uint time; } struct TransferInfos { mapping (uint => TransferInfo) ti; uint tc; } mapping (address => TransferInfos) transferInfo; event SetIsSendingLocked(address _from, bool _lock); event SetIsAllTransfersLocked(bool _lock); //------------------------------------------------------------------------------------- //from ExampleToken constructor() { decimals = 18; // Amount of decimals for display purposes name = "Meta Media Token"; // Set the name for display purposes symbol = 'MML'; // Set the symbol for display purposes uint initialBalance = (10 ** uint256(decimals)) * 1000*1000*1000; balances[msg.sender] = initialBalance; totalSupply = initialBalance; contrInitiator = msg.sender; thisContract =address(this); isTokenSupport = false; isAllTransfersLocked = true; oneTransferLimit = (10 ** uint256(decimals)) * 50*1000*1001; // to simulate no limit oneDayTransferLimit = (10 ** uint256(decimals)) * 50*1000*1001; // to simulate no limit // Ideally call token fallback here too } //------------------------------------------------------------------------------------- //from StandardToken function super_transfer(address _to, uint _value) internal returns (bool success) { require(!isSendingLocked[msg.sender]); require(_value <= oneTransferLimit); require(balances[msg.sender] >= _value); if(msg.sender == contrInitiator) { //no restricton } else { require(!isAllTransfersLocked); require(safeAdd(getLast24hSendingValue(msg.sender), _value) <= oneDayTransferLimit); } balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); uint tc=transferInfo[msg.sender].tc; transferInfo[msg.sender].ti[tc].value = _value; transferInfo[msg.sender].ti[tc].time = block.timestamp; transferInfo[msg.sender].tc = safeAdd(transferInfo[msg.sender].tc, 1); emit Transfer(msg.sender, _to, _value); return true; } function super_transferFrom(address _from, address _to, uint _value) internal returns (bool success) { require(!isSendingLocked[_from]); require(_value <= oneTransferLimit); require(balances[_from] >= _value); if(msg.sender == contrInitiator && _from == thisContract) { // no restriction } else { require(!isAllTransfersLocked); require(safeAdd(getLast24hSendingValue(_from), _value) <= oneDayTransferLimit); uint loc_allowance = allowed[_from][msg.sender]; require(loc_allowance >= _value); uint new_allowance = safeSub(loc_allowance, _value); allowed[_from][msg.sender] = new_allowance; emit Approval(_from, msg.sender, new_allowance); } balances[_from] = safeSub(balances[_from], _value); balances[_to] = safeAdd(balances[_to], _value); uint tc=transferInfo[_from].tc; transferInfo[_from].ti[tc].value = _value; transferInfo[_from].ti[tc].time = block.timestamp; transferInfo[_from].tc = safeAdd(transferInfo[_from].tc, 1); emit Transfer(_from, _to, _value); return true; } function balanceOf(address _owner) public override view returns (uint balance) { return balances[_owner]; } function approve(address _spender, uint _value) public override returns (bool success) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public override view returns (uint remaining) { return allowed[_owner][_spender]; } //------------------------------------------------------------------------------------- //from Standard223Token //function that is called when a user or another contract wants to transfer funds function transfer(address _to, uint _value, bytes memory _data) public override returns (bool success) { //filtering if the target is a contract with bytecode inside it if (!super_transfer(_to, _value)) assert(false); // do a normal token transfer if (isContract(_to)) { if(!contractFallback(msg.sender, _to, _value, _data)) assert(false); } return true; } function transferFrom(address _from, address _to, uint _value, bytes memory _data) public override returns (bool success) { if (!super_transferFrom(_from, _to, _value)) assert(false); // do a normal token transfer if (isContract(_to)) { if(!contractFallback(_from, _to, _value, _data)) assert(false); } return true; } function transfer(address _to, uint _value) public override returns (bool success) { return transfer(_to, _value, new bytes(0)); } function transferFrom(address _from, address _to, uint _value) public override returns (bool success) { return transferFrom(_from, _to, _value, new bytes(0)); } //function that is called when transaction target is a contract function contractFallback(address _origin, address _to, uint _value, bytes memory _data) private returns (bool success) { ERC223Receiver reciever = ERC223Receiver(_to); return reciever.tokenFallback(msg.sender, _origin, _value, _data); } //assemble the given address bytecode. If bytecode exists then the _addr is a contract. function isContract(address _addr) private 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; } //------------------------------------------------------------------------------------- //from Standard223Receiver Tkn tkn; struct Tkn { address addr; address sender; address origin; uint256 value; bytes data; bytes4 sig; } function tokenFallback(address _sender, address _origin, uint _value, bytes memory _data) public override returns (bool ok) { if (!supportsToken(msg.sender)) return false; // Problem: This will do a sstore which is expensive gas wise. Find a way to keep it in memory. tkn = Tkn(msg.sender, _sender, _origin, _value, _data, getSig(_data)); __isTokenFallback = true; // if (!address(this).delegatecall(_data)) return false; (bool success, bytes memory response) = address(this).delegatecall(_data); response = response; //!!!!! will it work? if(!success) return false; // avoid doing an overwrite to .token, which would be more expensive // makes accessing .tkn values outside tokenPayable functions unsafe __isTokenFallback = false; return true; } function getSig(bytes memory _data) private pure returns (bytes4 sig) { uint l = _data.length < 4 ? _data.length : 4; for (uint i = 0; i < l; i++) { sig = bytes4(uint32(uint32(sig) + uint8(_data[i]) * (2 ** (8 * (l - 1 - i))))); } } bool __isTokenFallback; modifier mod_tokenPayable() { if (!__isTokenFallback) assert(false); _; //_ is a special character used in modifiers } //function supportsToken(address token) public pure returns (bool); //moved up //------------------------------------------------------------------------------------- //from ExampleReceiver function tokenPayable() external mod_tokenPayable() { emit LogTokenPayable(0, tkn.addr, tkn.sender, tkn.value); } function supportsToken(address token) public override view returns (bool) { //do not need to to anything with that token address? //if (token == 0) { //attila addition if (token != thisContract) { //attila addition, support only our own token, not others' token return false; } if(!isTokenSupport) { //attila addition return false; } return true; } event LogTokenPayable(uint i, address token, address sender, uint value); //------------------------------------------------------------------------------------- // My extensions function setIsAllTransfersLocked(bool _lock) public { require(msg.sender == contrInitiator); isAllTransfersLocked = _lock; emit SetIsAllTransfersLocked(_lock); } function setIsSendingLocked(address _from, bool _lock) public { require(msg.sender == contrInitiator); isSendingLocked[_from] = _lock; emit SetIsSendingLocked(_from, _lock); } function getIsAllTransfersLocked() public view returns (bool ok) { return isAllTransfersLocked; } function getIsSendingLocked(address _from) public view returns (bool ok) { return isSendingLocked[_from]; } function getLast24hSendingValue(address _from) public view returns (uint totVal) { totVal = 0; //declared above; uint tc = transferInfo[_from].tc; for(uint i = tc ; i >= 1 ; i--) { // if(block.timestamp - transferInfo[_from].ti[i-1].time < 10 minutes) { // if(block.timestamp - transferInfo[_from].ti[i-1].time < 1 hours) { if(block.timestamp - transferInfo[_from].ti[i-1].time < 1 days) { totVal = safeAdd(totVal, transferInfo[_from].ti[i-1].value); } else { break; } require(tc - i < 99); } } function airdropIndividual(address[] memory _recipients, uint256[] memory _values, uint256 _elemCount, uint _totalValue) public returns (bool success) { require(_recipients.length == _elemCount); require(_values.length == _elemCount); require(_elemCount <= 50); uint256 totalValue = 0; for(uint i = 0; i< _recipients.length; i++) { totalValue = safeAdd(totalValue, _values[i]); } require(totalValue == _totalValue); for(uint i = 0; i< _recipients.length; i++) { transfer(_recipients[i], _values[i]); } return true; } }
343,950
11,832
5f0773259f0c344906f73f458cc667e32350f794110dc056478d9efdf2c96bde
34,492
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/c7/C79A68DDbf6DDD146b467A680644Db8dFE56D774_PopMart.sol
4,264
17,599
// SPDX-License-Identifier: MIT pragma solidity ^0.8.13; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. library SafeMath { function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } interface IERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address to, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address from, address to, uint256 amount) external returns (bool); } interface IERC20Metadata is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); } interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } interface 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; } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { _transferOwnership(_msgSender()); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } contract 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 {} } contract PopMart is ERC20, Ownable { using SafeMath for uint256; uint256 OPENING_INTERVAL = 3 minutes; IUniswapV2Router02 public immutable uniswapV2Router; address public immutable uniswapV2Pair; uint256 public transferStartTime; mapping(address => bool) private _isExcludedFromFees; constructor(string memory name_, string memory symbol_, uint256 totalSupply_, IUniswapV2Router02 uniswapV2Router_, uint256 transferStartTime_) payable ERC20(name_, symbol_) { uniswapV2Router = uniswapV2Router_; transferStartTime = transferStartTime_; uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(uniswapV2Router.WETH(), address(this)); excludeFromFees(owner(), true); _mint(msg.sender, totalSupply_ * 10 ** decimals()); } function isExcludedFromFees(address account) public view returns (bool) { return _isExcludedFromFees[account]; } function _transfer(address from, address to, uint256 amount) internal override { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); if (amount == 0) { super._transfer(from, to, 0); return; } require(_isTransferStart(from, to), "PopMart: transfer not started"); super._transfer(from, to, amount); } function _isTransferStart(address _from, address _to) private view returns (bool) { return transferStartTime.add(_to == uniswapV2Pair ? OPENING_INTERVAL : 0) <= block.timestamp || _isExcludedFromFees[_from] || _isExcludedFromFees[_to]; } function setTransferStartTime(uint256 _transferStartTime) external onlyOwner { transferStartTime = _transferStartTime; } function excludeFromFees(address account, bool excluded) public onlyOwner { if (_isExcludedFromFees[account] != excluded) { _isExcludedFromFees[account] = excluded; emit ExcludeFromFees(account, excluded); } } function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner { for (uint256 i = 0; i < accounts.length; i++) { _isExcludedFromFees[accounts[i]] = excluded; } emit ExcludeMultipleAccountsFromFees(accounts, excluded); } event ExcludeFromFees(address indexed account, bool isExcluded); event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded); }
47,574
11,833
eca5122266bb847fc82d768ad44357f419e8af9753a81523c66dc6159fcef6a4
21,958
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0x94d940ceb4eb87a18c903804bb2c44910edb6453_nonpublicVarAccessdByPublicFunc.sol
3,604
14,195
pragma solidity 0.5.14; 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; } } 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 LexDAORole is Context { using Roles for Roles.Role; event LexDAOAdded(address indexed account); event LexDAORemoved(address indexed account); Roles.Role private _lexDAOs; constructor () internal { _addLexDAO(_msgSender()); } modifier onlyLexDAO() { require(isLexDAO(_msgSender()), "LexDAORole: caller does not have the LexDAO role"); _; } function isLexDAO(address account) public view returns (bool) { return _lexDAOs.has(account); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function addLexDAO(address account) public onlyLexDAO { _addLexDAO(account); } function renounceLexDAO() public { _removeLexDAO(_msgSender()); } function _addLexDAO(address account) internal { _lexDAOs.add(account); emit LexDAOAdded(account); } function _removeLexDAO(address account) internal { _lexDAOs.remove(account); emit LexDAORemoved(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; } } 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 ICHAI { function balanceOf(address usr) external returns (uint); function transfer(address dst, uint wad) external returns (bool); function dai(address usr) external returns (uint wad); function dai(uint chai) external returns (uint wad); function join(address dst, uint wad) external; } interface ICERC20 { function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function mint(uint256) external returns (uint256); function exchangeRateCurrent() external returns (uint256); function supplyRatePerBlock() external returns (uint256); } contract LexGrow is LexDAORole { // Deal depositing for Digital Dollars that earn on DSR & Compound using SafeMath for uint256; // $DAI details: address private daiToken = 0x6B175474E89094C44Da98b954EedeAC495271d0F; IERC20 internal dai = IERC20(daiToken); // $CHAI details: address private chaiToken = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215; ICHAI internal chai = ICHAI(chaiToken); // <$> LXG <$> details: address private vault = address(this); address payable internal manager; uint8 public version = 2; uint256 internal depositFee; uint256 internal lxg; // index for registered LexGrow string public emoji = "11111"; mapping (uint256 => Deposit) internal deposit; struct Deposit { address client; address provider; address compoundToken; uint256 amount; uint256 wrap; uint256 termination; uint256 index; string details; bool dsr; bool disputed; bool released; } // LXG Contract Events: event Log(string, uint256); // log for Compound interactions event Registered(address indexed client, address indexed provider, uint256 indexed index); event Released(uint256 indexed index); event Disputed(uint256 indexed index, string indexed details); event Resolved(address indexed resolver, uint256 indexed index, string indexed details); event ManagerTransferred(address indexed manager, string indexed details); constructor () public { dai.approve(chaiToken, uint(-1)); manager = msg.sender; depositFee = 0; } function dealDepositDSR(// register $DAI deal deposit with DSR via $CHAI; arbitration via lexDAO address provider, uint256 amount, uint256 termination, string memory details) public payable { require(msg.value == depositFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 index = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC lxg = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC dai.transferFrom(msg.sender, vault, amount); // deposit $DAI //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 balance = chai.balanceOf(vault); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC chai.join(vault, amount); // wrap into $CHAI and store in vault //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC deposit[index] = Deposit(// log deal deposit details //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC msg.sender, provider, chaiToken, //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC amount, chai.balanceOf(vault).sub(balance), //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC termination, index, details, true, false, false); address(manager).transfer(msg.value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Registered(msg.sender, provider, index); } function dealDepositCompound(// register $cToken deal deposit with interest via Compound; arbitration via lexDAO address provider, address underlyingToken, address compoundToken, uint256 amount, uint256 termination, string memory details) public payable returns (uint) { require(msg.value == depositFee); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC IERC20 uToken = IERC20(underlyingToken); ICERC20 cToken = ICERC20(compoundToken); // Amount of current exchange rate from $cToken to underlying uint256 exchangeRateMantissa = cToken.exchangeRateCurrent(); emit Log("Exchange Rate (scaled up by 1e18)", exchangeRateMantissa); // Amount added to supply balance this block uint256 supplyRateMantissa = cToken.supplyRatePerBlock(); emit Log("Supply Rate: (scaled up by 1e18)", supplyRateMantissa); // Approve transfer on underlying ERC20 token contract uToken.approve(compoundToken, amount); // Mint cTokens uToken.transferFrom(msg.sender, vault, amount); // deposit $uToken //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint256 balance = cToken.balanceOf(vault); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint mintResult = cToken.mint(amount); // wrap into $cToken and store in vault uint256 index = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC lxg = lxg.add(1); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC deposit[index] = Deposit(// log deal deposit details //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC msg.sender, provider, compoundToken, amount, cToken.balanceOf(vault).sub(balance), //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC termination, index, details, false, false, false); address(manager).transfer(msg.value); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Registered(msg.sender, provider, index); return mintResult; } function release(uint256 index) public { Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(depos.disputed == false); // program safety check / status require(depos.released == false); // program safety check / status require(now <= depos.termination); // program safety check / time require(msg.sender == depos.client); // program safety check / authorization if (depos.dsr == true) { chai.transfer(depos.provider, depos.wrap); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } else { ICERC20 cToken = ICERC20(depos.compoundToken); cToken.transfer(depos.provider, depos.wrap); } depos.released = true; emit Released(index); } function withdraw(uint256 index) public { // withdraw deposit wrap if termination time passes Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(depos.disputed == false); // program safety check / status require(depos.released == false); // program safety check / status require(now >= depos.termination); // program safety check / time if (depos.dsr == true) { chai.transfer(depos.client, depos.wrap); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } else { ICERC20 cToken = ICERC20(depos.compoundToken); cToken.transfer(depos.client, depos.wrap); } depos.released = true; emit Released(index); } function dispute(uint256 index, string memory details) public { Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(depos.released == false); // program safety check / status require(now <= depos.termination); // program safety check / time require(msg.sender == depos.client || msg.sender == depos.provider); // program safety check / authorization depos.disputed = true; emit Disputed(index, details); } function resolve(uint256 index, uint256 clientAward, uint256 providerAward, string memory details) public onlyLexDAO { Deposit storage depos = deposit[index]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(depos.disputed == true); // program safety check / status require(depos.released == false); // program safety check / status require(clientAward.add(providerAward) == depos.wrap); // program safety check / economics require(msg.sender != depos.client); // program safety check / authorization require(msg.sender != depos.provider); // program safety check / authorization if (depos.dsr == true) { chai.transfer(depos.client, clientAward); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC chai.transfer(depos.provider, providerAward); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } else { ICERC20 cToken = ICERC20(depos.compoundToken); cToken.transfer(depos.client, clientAward); cToken.transfer(depos.provider, providerAward); } depos.released = true; emit Resolved(msg.sender, index, details); } function newDepositFee(uint256 weiAmount) public { require(msg.sender == manager); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC depositFee = weiAmount; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function transferManager(address payable newManager, string memory details) public { require(msg.sender == manager); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC manager = newManager; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit ManagerTransferred(manager, details); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } }
279,775
11,834
624d02de50b313d6c7769b43e190098c56ba3a7a69398d31d6343e0fe76fdf92
18,121
.sol
Solidity
false
287517600
renardbebe/Smart-Contract-Benchmark-Suites
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
dataset/UR/0xefc1752f4b196d6da51feb3fa5383b0fed2e4f8a.sol
5,112
17,924
pragma solidity ^0.5.7; library SafeMath { function mul(uint a, uint b) internal pure returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint a, uint b) internal pure returns (uint) { uint c = a / b; return c; } function sub(uint a, uint b) internal pure returns (uint) { assert(b <= a); return a - b; } function add(uint a, uint b) internal pure returns (uint) { uint c = a + b; assert(c >= a); return c; } } contract Ownable { address owner; address Main_address; address public main_address; address Upline_address; address public upline_address; mapping (address => bool) managers; constructor() public { owner = msg.sender; main_address = msg.sender; upline_address = msg.sender; } modifier onlyOwner() { require(msg.sender == owner, "Only for owner"); _; } function transferOwnership(address _owner) public onlyOwner { owner = _owner; } } contract ETHStvo is Ownable { event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time); event Upgrade(uint indexed _user, uint _level, uint _price, uint _time); event Payment(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time); event Lost(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time); mapping (uint => uint) public LEVEL_PRICE; mapping (uint => uint) SPONSOR; mapping (uint => uint) INTRODUCER; mapping (uint => uint) UPLINE; mapping (uint => uint) FEE; uint REFERRAL_LIMIT = 3; struct UserStruct { bool isExist; uint level; uint introducedTotal; uint referrerID; uint introducerID; address wallet; uint[] introducers; uint[] referrals; } mapping (uint => UserStruct) public users; mapping (address => uint) public userList; mapping (uint => uint) public stats_level; uint public currentUserID = 0; uint public stats_total = 0 ether; uint stats = 0 ether; uint Stats = 0 ether; bool public paused = false; constructor() public { LEVEL_PRICE[0.1 ether] = 1; LEVEL_PRICE[0.15 ether] = 2; LEVEL_PRICE[0.5 ether] = 3; LEVEL_PRICE[1.5 ether] = 4; LEVEL_PRICE[3.5 ether] = 5; LEVEL_PRICE[7 ether] = 6; LEVEL_PRICE[20 ether] = 7; LEVEL_PRICE[60 ether] = 8; SPONSOR[0.1 ether] = 0.027 ether; SPONSOR[0.15 ether] = 0.105 ether; SPONSOR[0.5 ether] = 0.35 ether; SPONSOR[1.5 ether] = 1.05 ether; SPONSOR[3.5 ether] = 2.45 ether; SPONSOR[7 ether] = 4.9 ether; SPONSOR[20 ether] = 14 ether; SPONSOR[60 ether] = 42 ether; INTRODUCER[0.1 ether] = 0.0315 ether; INTRODUCER[0.15 ether] = 0.0225 ether; INTRODUCER[0.5 ether] = 0.075 ether; INTRODUCER[1.5 ether] = 0.225 ether; INTRODUCER[3.5 ether] = 0.525 ether; INTRODUCER[7 ether] = 1.05 ether; INTRODUCER[20 ether] = 3 ether; INTRODUCER[60 ether] = 9 ether; UPLINE[0.1 ether] = 0.00504 ether; UPLINE[0.15 ether] = 0.0036 ether; UPLINE[0.5 ether] = 0.012 ether; UPLINE[1.5 ether] = 0.036 ether; UPLINE[3.5 ether] = 0.084 ether; UPLINE[7 ether] = 0.168 ether; UPLINE[20 ether] = 0.48 ether; UPLINE[60 ether] = 1.44 ether; FEE[0.1 ether] = 0.01 ether; UserStruct memory userStruct; currentUserID++; userStruct = UserStruct({ isExist: true, level: 18, introducedTotal: 0, referrerID: 0, introducerID: 0, wallet: main_address, introducers: new uint[](0), referrals: new uint[](0) }); users[currentUserID] = userStruct; userList[main_address] = currentUserID; } function setMainAddress(address _main_address) public onlyOwner { require(userList[_main_address] == 0, 'Address is already in use by another user'); delete userList[main_address]; userList[_main_address] = uint(1); main_address = _main_address; users[1].wallet = _main_address; } function setAddress(address _main_address, address _upline_address) public onlyOwner { Main_address = _main_address; Upline_address = _upline_address; } function setPaused(bool _paused) public onlyOwner { paused = _paused; } function getStats() public view onlyOwner returns(uint) { return Stats; } function setLevelPrice(uint _price, uint _level) public onlyOwner { LEVEL_PRICE[_price] = _level; } function setSponsor(uint _price, uint _sponsor) public onlyOwner { SPONSOR[_price] = _sponsor; } function setIntroducer(uint _price, uint _introducer) public onlyOwner { INTRODUCER[_price] = _introducer; } function setUpline(uint _price, uint _upline) public onlyOwner { UPLINE[_price] = _upline; } function setFee(uint _price, uint _fee) public onlyOwner { FEE[_price] = _fee; } function setCurrentUserID(uint _currentUserID) public onlyOwner { currentUserID = _currentUserID; } function viewStats() public view onlyOwner returns(uint) { return stats; } function addManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner { managers[manager_1] = true; managers[manager_2] = true; managers[manager_3] = true; managers[manager_4] = true; managers[manager_5] = true; managers[manager_6] = true; managers[manager_7] = true; managers[manager_8] = true; managers[manager_9] = true; managers[manager_10] = true; } function removeManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner { managers[manager_1] = false; managers[manager_2] = false; managers[manager_3] = false; managers[manager_4] = false; managers[manager_5] = false; managers[manager_6] = false; managers[manager_7] = false; managers[manager_8] = false; managers[manager_9] = false; managers[manager_10] = false; } function addManager(address manager) public onlyOwner { managers[manager] = true; } function removeManager(address manager) public onlyOwner { managers[manager] = false; } function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _referral1, uint _referral2, uint _referral3, uint _level, uint _introducedTotal) public { require(msg.sender == owner || managers[msg.sender], "Only for owner"); require(_userID > 1, 'Invalid user ID'); require(_level > 0, 'Invalid level'); require(_introducedTotal >= 0, 'Invalid introduced total'); require(_wallet != address(0), 'Invalid user wallet'); if(_userID > 1){ require(_referrerID > 0, 'Invalid referrer ID'); require(_introducerID > 0, 'Invalid introducer ID'); } if(_userID > currentUserID){ currentUserID++; } if(users[_userID].isExist){ delete userList[users[_userID].wallet]; delete users[_userID]; } UserStruct memory userStruct; userStruct = UserStruct({ isExist: true, level: _level, introducedTotal: _introducedTotal, referrerID: _referrerID, introducerID: _introducerID, wallet: _wallet, introducers: new uint[](0), referrals: new uint[](0) }); users[_userID] = userStruct; userList[_wallet] = _userID; uint upline_2_id = users[users[_introducerID].introducerID].introducerID; uint upline_3_id = users[upline_2_id].introducerID; uint upline_4_id = users[upline_3_id].introducerID; if(users[_introducerID].introducerID >0){ users[_userID].introducers.push(users[_introducerID].introducerID); } if(upline_2_id >0){ users[_userID].introducers.push(upline_2_id); } if(upline_3_id >0){ users[_userID].introducers.push(upline_3_id); } if(upline_4_id >0){ users[_userID].introducers.push(upline_4_id); } if(_referral1 != uint(0)){ users[_userID].referrals.push(_referral1); } if(_referral2 != uint(0)){ users[_userID].referrals.push(_referral2); } if(_referral3 != uint(0)){ users[_userID].referrals.push(_referral3); } } function () external payable { require(!paused); require(LEVEL_PRICE[msg.value] > 0, 'You have sent incorrect payment amount'); if(LEVEL_PRICE[msg.value] == 1){ uint referrerID = 0; address referrer = bytesToAddress(msg.data); if(referrer == address(0)){ referrerID = 1; } else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){ referrerID = userList[referrer]; } else { revert('Incorrect referrer'); } if(users[userList[msg.sender]].isExist){ revert('You are already signed up'); } else { registerUser(referrerID); } } else if(users[userList[msg.sender]].isExist){ upgradeUser(LEVEL_PRICE[msg.value]); } else { revert("Please buy first level"); } } function registerUser(uint _referrerID) internal { require(!users[userList[msg.sender]].isExist, 'You are already signed up'); require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID'); require(LEVEL_PRICE[msg.value] == 1, 'You have sent incorrect payment amount'); uint _introducerID = _referrerID; if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT) { _referrerID = findFreeReferrer(_referrerID); } UserStruct memory userStruct; currentUserID++; userStruct = UserStruct({ isExist : true, level: 1, introducedTotal: 0, referrerID : _referrerID, introducerID : _introducerID, wallet : msg.sender, introducers: new uint[](0), referrals : new uint[](0) }); users[currentUserID] = userStruct; userList[msg.sender] = currentUserID; uint upline_1_id = users[_introducerID].introducerID; uint upline_2_id = users[upline_1_id].introducerID; uint upline_3_id = users[upline_2_id].introducerID; uint upline_4_id = users[upline_3_id].introducerID; if(upline_1_id >0){ users[currentUserID].introducers.push(upline_1_id); } if(upline_2_id >0){ users[currentUserID].introducers.push(upline_2_id); } if(upline_3_id >0){ users[currentUserID].introducers.push(upline_3_id); } if(upline_4_id >0){ users[currentUserID].introducers.push(upline_4_id); } if(_referrerID != 1){ users[_referrerID].referrals.push(currentUserID); } users[_referrerID].introducedTotal += 1; stats_level[1] = SafeMath.add(stats_level[1], uint(1)); processPayment(currentUserID, 1); emit Register(currentUserID, _referrerID, _introducerID, now); } function upgradeUser(uint _level) internal { require(users[userList[msg.sender]].isExist, 'You are not signed up yet'); require(_level >= 2 && _level <= 18, 'Incorrect level'); require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount'); require(users[userList[msg.sender]].level < _level, 'You have already activated this level'); uint level_previous = SafeMath.sub(_level, uint(1)); require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first'); users[userList[msg.sender]].level = _level; stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1)); stats_level[_level] = SafeMath.add(stats_level[_level], uint(1)); processPayment(userList[msg.sender], _level); emit Upgrade(userList[msg.sender], _level, msg.value, now); } function processPayment(uint _user, uint _level) internal { uint sponsor_id; uint introducer_id = users[_user].introducerID; uint money_left = msg.value; if(FEE[msg.value] > 0){ address(uint160(Main_address)).transfer(FEE[msg.value]); money_left = SafeMath.sub(money_left,FEE[msg.value]); stats = SafeMath.add(stats,FEE[msg.value]); } if(_level == 1 || _level == 5 || _level == 9 || _level == 13 || _level == 17){ sponsor_id = users[_user].referrerID; } else if(_level == 2 || _level == 6 || _level == 10 || _level == 14 || _level == 18){ sponsor_id = users[users[_user].referrerID].referrerID; } else if(_level == 3 || _level == 7 || _level == 11 || _level == 15){ sponsor_id = users[users[users[_user].referrerID].referrerID].referrerID; } else if(_level == 4 || _level == 8 || _level == 12 || _level == 16){ sponsor_id = users[users[users[users[_user].referrerID].referrerID].referrerID].referrerID; } stats_total = SafeMath.add(stats_total,msg.value); if(!users[sponsor_id].isExist || users[sponsor_id].level < _level){ if(users[_user].referrerID != 1){ emit Lost(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now); } } else { address(uint160(users[sponsor_id].wallet)).transfer(SPONSOR[msg.value]); money_left = SafeMath.sub(money_left,SPONSOR[msg.value]); emit Payment(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now); } if(users[introducer_id].isExist){ if(INTRODUCER[msg.value] > 0){ if(!users[introducer_id].isExist || users[introducer_id].level < _level){ if(introducer_id != 1){ emit Lost(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now); } } else { address(uint160(users[introducer_id].wallet)).transfer(INTRODUCER[msg.value]); money_left = SafeMath.sub(money_left,INTRODUCER[msg.value]); emit Payment(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now); } } if(UPLINE[msg.value] > 0){ if(introducer_id > 0 && users[users[introducer_id].introducerID].isExist){ for (uint i=0; i<users[_user].introducers.length; i++) { if(users[users[_user].introducers[i]].isExist && users[users[_user].introducers[i]].level >= _level && (users[users[_user].introducers[i]].introducedTotal >= SafeMath.add(i, uint(1)) || users[users[_user].introducers[i]].introducedTotal >= uint(3))){ address(uint160(users[users[_user].introducers[i]].wallet)).transfer(UPLINE[msg.value]); emit Payment(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now); money_left = SafeMath.sub(money_left,UPLINE[msg.value]); } else { emit Lost(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now); } } } } } if(money_left > 0){ address(uint160(Upline_address)).transfer(money_left); Stats = SafeMath.add(Stats,money_left); } } function findFreeReferrer(uint _user) public view returns(uint) { require(users[_user].isExist, 'User does not exist'); if(users[_user].referrals.length < REFERRAL_LIMIT){ return _user; } uint[] memory referrals = new uint[](363); referrals[0] = users[_user].referrals[0]; referrals[1] = users[_user].referrals[1]; referrals[2] = users[_user].referrals[2]; uint freeReferrer; bool noFreeReferrer = true; for(uint i = 0; i < 363; i++){ if(users[referrals[i]].referrals.length == REFERRAL_LIMIT){ if(i < 120){ referrals[(i+1)*3] = users[referrals[i]].referrals[0]; referrals[(i+1)*3+1] = users[referrals[i]].referrals[1]; referrals[(i+1)*3+2] = users[referrals[i]].referrals[2]; } } else { noFreeReferrer = false; freeReferrer = referrals[i]; break; } } if(noFreeReferrer){ freeReferrer = 1; } return freeReferrer; } function viewUserReferrals(uint _user) public view returns(uint[] memory) { return users[_user].referrals; } function viewUserIntroducers(uint _user) public view returns(uint[] memory) { return users[_user].introducers; } function viewUserLevel(uint _user) public view returns(uint) { return users[_user].level; } function bytesToAddress(bytes memory bys) private pure returns (address addr) { assembly { addr := mload(add(bys, 20)) } } }
163,228
11,835
a866f36e089c5c00fbaba49402bc62a4f8570dcac2fab61058a524e06f112ad5
20,069
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x7b2f9706cd8473b4f5b7758b0171a9933fc6c4d6.sol
2,985
11,397
pragma solidity ^0.4.17; contract ERC20 { function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); 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 Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } /// @dev Crowdsale interface for Etheal Normal Sale, functions needed from outside. contract iEthealSale { bool public paused; uint256 public minContribution; uint256 public whitelistThreshold; mapping (address => uint256) public stakes; function setPromoBonus(address _investor, uint256 _value) public; function buyTokens(address _beneficiary) public payable; function depositEth(address _beneficiary, uint256 _time, bytes _whitelistSign) public payable; function depositOffchain(address _beneficiary, uint256 _amount, uint256 _time) public; function hasEnded() public constant returns (bool); } contract HasNoTokens is Ownable { event ExtractedTokens(address indexed _token, address indexed _claimer, uint _amount); /// @notice This method can be used to extract mistakenly /// sent tokens to this contract. /// @param _token The address of the token contract that you want to recover /// set to 0 in case you want to extract ether. /// @param _claimer Address that tokens will be send to function extractTokens(address _token, address _claimer) onlyOwner public { if (_token == 0x0) { _claimer.transfer(this.balance); return; } ERC20 token = ERC20(_token); uint balance = token.balanceOf(this); token.transfer(_claimer, balance); ExtractedTokens(_token, _claimer, balance); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Token { function totalSupply () view returns (uint256 supply); function balanceOf (address _owner) view 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) view returns (uint256 remaining); event Transfer (address indexed _from, address indexed _to, uint256 _value); event Approval (address indexed _owner, address indexed _spender, uint256 _value); } contract AbstractToken is Token { using SafeMath for uint; function AbstractToken () { // Do nothing } function balanceOf (address _owner) view returns (uint256 balance) { return accounts[_owner]; } function transfer (address _to, uint256 _value) returns (bool success) { uint256 fromBalance = accounts[msg.sender]; if (fromBalance < _value) return false; if (_value > 0 && msg.sender != _to) { accounts[msg.sender] = fromBalance.sub(_value); accounts[_to] = accounts[_to].add(_value); Transfer(msg.sender, _to, _value); } return true; } function transferFrom (address _from, address _to, uint256 _value) returns (bool success) { uint256 spenderAllowance = allowances[_from][msg.sender]; if (spenderAllowance < _value) return false; uint256 fromBalance = accounts[_from]; if (fromBalance < _value) return false; allowances[_from][msg.sender] = spenderAllowance.sub(_value); if (_value > 0 && _from != _to) { accounts[_from] = fromBalance.sub(_value); accounts[_to] = accounts[_to].add(_value); Transfer(_from, _to, _value); } return true; } function approve (address _spender, uint256 _value) returns (bool success) { allowances[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance (address _owner, address _spender) view returns (uint256 remaining) { return allowances[_owner][_spender]; } mapping (address => uint256) accounts; mapping (address => mapping (address => uint256)) private allowances; } contract AbstractVirtualToken is AbstractToken { using SafeMath for uint; uint256 constant MAXIMUM_TOKENS_COUNT = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; uint256 constant BALANCE_MASK = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF; uint256 constant MATERIALIZED_FLAG_MASK = 0x8000000000000000000000000000000000000000000000000000000000000000; function AbstractVirtualToken () { // Do nothing } function totalSupply () view returns (uint256 supply) { return tokensCount; } function balanceOf (address _owner) constant returns (uint256 balance) { return (accounts[_owner] & BALANCE_MASK).add(getVirtualBalance(_owner)); } function transfer (address _to, uint256 _value) returns (bool success) { if (_value > balanceOf(msg.sender)) return false; else { materializeBalanceIfNeeded(msg.sender, _value); return AbstractToken.transfer(_to, _value); } } function transferFrom (address _from, address _to, uint256 _value) returns (bool success) { if (_value > allowance(_from, msg.sender)) return false; if (_value > balanceOf(_from)) return false; else { materializeBalanceIfNeeded(_from, _value); return AbstractToken.transferFrom(_from, _to, _value); } } function virtualBalanceOf (address _owner) internal view returns (uint256 _virtualBalance); function getVirtualBalance (address _owner) private view returns (uint256 _virtualBalance) { if (accounts [_owner] & MATERIALIZED_FLAG_MASK != 0) return 0; else { _virtualBalance = virtualBalanceOf(_owner); uint256 maxVirtualBalance = MAXIMUM_TOKENS_COUNT.sub(tokensCount); if (_virtualBalance > maxVirtualBalance) _virtualBalance = maxVirtualBalance; } } function materializeBalanceIfNeeded (address _owner, uint256 _value) private { uint256 storedBalance = accounts[_owner]; if (storedBalance & MATERIALIZED_FLAG_MASK == 0) { // Virtual balance is not materialized yet if (_value > storedBalance) { // Real balance is not enough uint256 virtualBalance = getVirtualBalance(_owner); require (_value.sub(storedBalance) <= virtualBalance); accounts[_owner] = MATERIALIZED_FLAG_MASK | storedBalance.add(virtualBalance); tokensCount = tokensCount.add(virtualBalance); } } } uint256 tokensCount; } contract EthealPromoToken is HasNoTokens, AbstractVirtualToken { // Balance threshold to assign virtual tokens to the owner of higher balances then this threshold. uint256 private constant VIRTUAL_THRESHOLD = 0.1 ether; // Number of virtual tokens to assign to the owners of balances higher than virtual threshold. uint256 private constant VIRTUAL_COUNT = 911; // crowdsale to set bonus when sending token iEthealSale public crowdsale; // logging promo token activation event LogBonusSet(address indexed _address, uint256 _amount); //////////////// // Basic functions //////////////// /// @dev Constructor, crowdsale address can be 0x0 function EthealPromoToken(address _crowdsale) { crowdsale = iEthealSale(_crowdsale); } /// @dev Setting crowdsale, crowdsale address can be 0x0 function setCrowdsale(address _crowdsale) public onlyOwner { crowdsale = iEthealSale(_crowdsale); } /// @notice Get virtual balance of the owner of given address. /// @param _owner address to get virtual balance for the owner /// @return virtual balance of the owner of given address function virtualBalanceOf(address _owner) internal view returns (uint256) { return _owner.balance >= VIRTUAL_THRESHOLD ? VIRTUAL_COUNT : 0; } /// @notice Get name of this token. function name() public pure returns (string result) { return "An Etheal Promo"; } /// @notice Get symbol of this token. function symbol() public pure returns (string result) { return "HEALP"; } /// @notice Get number of decimals for this token. function decimals() public pure returns (uint8 result) { return 0; } //////////////// // Set sale bonus //////////////// /// @dev Internal function for setting sale bonus function setSaleBonus(address _from, address _to, uint256 _value) internal { if (address(crowdsale) == address(0)) return; if (_value == 0) return; if (_to == address(1) || _to == address(this) || _to == address(crowdsale)) { crowdsale.setPromoBonus(_from, _value); LogBonusSet(_from, _value); } } /// @dev Override transfer function to set sale bonus function transfer(address _to, uint256 _value) public returns (bool) { bool success = super.transfer(_to, _value); if (success) { setSaleBonus(msg.sender, _to, _value); } return success; } /// @dev Override transfer function to set sale bonus function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { bool success = super.transferFrom(_from, _to, _value); if (success) { setSaleBonus(_from, _to, _value); } return success; } //////////////// // Extra //////////////// /// @notice Notify owners about their virtual balances. function massNotify(address[] _owners) public onlyOwner { for (uint256 i = 0; i < _owners.length; i++) { Transfer(address(0), _owners[i], VIRTUAL_COUNT); } } /// @notice Kill this smart contract. function kill() public onlyOwner { selfdestruct(owner); } }
213,667
11,836
3261a7ee420df15f60fbb85ff9dd61c1511601d5200bf526384398babadbfbd6
30,780
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xe8B79104dC307879Dc707545Dc7E0b6E5C1554d6/contract.sol
4,039
16,591
// SPDX-License-Identifier: Unlicensed pragma solidity 0.6.12; // library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } interface IBEP20 { function totalSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function getOwner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } // library Address { function isContract(address account) internal view returns (bool) { // 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); } } } } // library SafeBEP20 { using SafeMath for uint256; using Address for address; function safeTransfer(IBEP20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IBEP20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeBEP20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IBEP20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed"); } } } // abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } // abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Presale is Ownable { using SafeMath for uint256; using SafeBEP20 for IBEP20; uint256 private immutable _referrerFee = 3; IBEP20 public token; uint256 public immutable softCap; uint256 public immutable hardCap; uint256 public immutable tokensPerBnb; uint256 public immutable minContribution; uint256 public immutable maxContribution; uint256 public immutable startTime; uint256 public immutable endTime; uint256 public weiRaised; bool public finalized; mapping(address => uint256) public tokenContributions; mapping(address => uint256) public referrerContributions; mapping(address => uint256) public totalContributions; mapping(address => uint256) public refunds; mapping(address => uint256) public referredTokens; mapping(address => uint256) public claimedTokens; mapping(address => address[]) public referredAddresses; event TokenPurchase(address indexed beneficiary, uint256 weiAmount); event TokenClaim(address indexed beneficiary, uint256 tokenAmount); event Refund(address indexed beneficiary, uint256 weiAmount); event PresaleFinalized(uint256 weiAmount); constructor(IBEP20 _token, uint256 _softCap, uint256 _hardCap, uint256 _tokensPerBnb, uint256 _minContribution, uint256 _maxContribution, uint256 _startTime, uint256 _endTime) public { token = _token; softCap = _softCap; hardCap = _hardCap; tokensPerBnb = _tokensPerBnb; minContribution = _minContribution; maxContribution = _maxContribution; startTime = _startTime; endTime = _endTime; } receive() external payable { _buyTokens(msg.sender, address(0)); } function contribute(address referrer) public payable { require(referrer != msg.sender, "EFutureCoinPresale: self referral not allowed"); _buyTokens(msg.sender, referrer); } function _buyTokens(address beneficiary, address referrer) internal { uint256 weiToHardcap = hardCap.sub(weiRaised); uint256 weiAmount = weiToHardcap < msg.value ? weiToHardcap : msg.value; _buyTokens(beneficiary, referrer, weiAmount); if (weiAmount < msg.value) { uint256 refund = msg.value.sub(weiAmount); payable(beneficiary).transfer(refund); } } function _buyTokens(address beneficiary, address referrer, uint256 weiAmount) internal { _validatePurchase(beneficiary, weiAmount); weiRaised = weiRaised.add(weiAmount); tokenContributions[beneficiary] = tokenContributions[beneficiary].add(weiAmount); totalContributions[beneficiary] = totalContributions[beneficiary].add(weiAmount); if (referrer != address(0)) { uint256 referrerFeeAmount = weiAmount.mul(_referrerFee).div(10**2); referrerContributions[referrer] = referrerContributions[referrer] .add(referrerFeeAmount); totalContributions[referrer] = totalContributions[referrer].add(referrerFeeAmount); referredAddresses[referrer].push(beneficiary); } emit TokenPurchase(beneficiary, weiAmount); } function _validatePurchase(address beneficiary, uint256 weiAmount) internal view { require(isOpen(), "EFutureCoinPresale: sale is not open"); require(!hasEnded(), "EFutureCoinPresale: sale is over"); require(weiAmount >= minContribution, "EFutureCoinPresale: min contribution criteria not met"); require(tokenContributions[beneficiary].add(weiAmount) <= maxContribution, "EFutureCoinPresale: max contribution criteria not met"); this; } function claimTokens() external { require(hasEnded(), "EFutureCoinPresale: sale is not over"); require(softCapReached(), "EFutureCoinPresale: soft cap not reached, refund is available"); require(tokenContributions[msg.sender] > 0, "EFutureCoinPresale: nothing to claim"); uint256 tokens = _getTokenAmount(totalContributions[msg.sender]); referredTokens[msg.sender] = _getTokenAmount(referrerContributions[msg.sender]); totalContributions[msg.sender] = 0; tokenContributions[msg.sender] = 0; referrerContributions[msg.sender] = 0; claimedTokens[msg.sender] = tokens; token.safeTransfer(msg.sender, tokens); emit TokenClaim(msg.sender, tokens); } function claimRefund() external { require(hasEnded(), "EFutureCoinPresale: sale is not over"); require(!softCapReached(), "EFutureCoinPresale: soft cap reached, claimTokens is available"); require(tokenContributions[msg.sender] > 0, "EFutureCoinPresale: nothing to claim"); uint256 refundAmount = tokenContributions[msg.sender]; totalContributions[msg.sender] = 0; tokenContributions[msg.sender] = 0; referrerContributions[msg.sender] = 0; refunds[msg.sender] = refundAmount; payable(msg.sender).transfer(refundAmount); emit Refund(msg.sender, refundAmount); } function endPresale() external onlyOwner { require(!finalized, "EFutureCoinPresale: sale is already over"); finalized = true; if (weiRaised > softCap) { uint256 totalWeiRaised = address(this).balance; payable(owner()).transfer(totalWeiRaised); } emit PresaleFinalized(weiRaised); } function withdrawTokens() public onlyOwner { require(finalized, "EFutureCoinPresale: sale is not over"); uint256 tokens = token.balanceOf(address(this)); token.transfer(owner(), tokens); } function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) { return weiAmount.mul(tokensPerBnb).div(1e18); } function getReferredAddresses(address referrerAddr) public view returns (address[] memory) { return referredAddresses[referrerAddr]; } function isOpen() public view returns (bool) { return block.timestamp >= startTime && block.timestamp <= endTime; } function hasEnded() public view returns (bool) { return finalized || now >= endTime || weiRaised >= hardCap; } function softCapReached() public view returns (bool) { return weiRaised >= softCap; } }
249,619
11,837
ad055ccd925ef3fa4242626c58d96a4a23a148308a0ae3aadbf8eb10b8e45315
10,273
.sol
Solidity
false
111633870
bokkypoobah/Tokens
97950a9e4915596d1ec00887c3c1812cfdb122a2
Mainnet-token-contracts-20180610/contracts/0x80fb784b7ed66730e8b1dbd9820afd29931aab03-LEND-EthLend.sol
2,641
9,879
pragma solidity ^0.4.16; contract SafeMath { function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function safeSub(uint a, uint b) internal returns (uint) { assert(b <= a); return a - b; } function safeAdd(uint a, uint b) internal returns (uint) { uint c = a + b; assert(c>=a && c>=b); return c; } } // Standard token interface (ERC 20) // https://github.com/ethereum/EIPs/issues/20 contract Token is SafeMath { // Functions: /// @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 function transfer(address _to, uint256 _value) returns(bool); /// @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); /// @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); // Events: event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract StdToken is Token { // Fields: mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; uint public supply = 0; // Functions: function transfer(address _to, uint256 _value) returns(bool) { require(balances[msg.sender] >= _value); require(balances[_to] + _value > balances[_to]); 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) returns(bool){ require(balances[_from] >= _value); require(allowed[_from][msg.sender] >= _value); require(balances[_to] + _value > balances[_to]); balances[_to] = safeAdd(balances[_to],_value); balances[_from] = safeSub(balances[_from],_value); allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value); Transfer(_from, _to, _value); return true; } function totalSupply() constant returns (uint256) { return supply; } function balanceOf(address _owner) constant returns (uint256) { 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) { return allowed[_owner][_spender]; } } contract EthLendToken is StdToken { /// Fields: string public constant name = "EthLend Token"; string public constant symbol = "LEND"; uint public constant decimals = 18; // this includes DEVELOPERS_BONUS uint public constant TOTAL_SUPPLY = 1300000000 * (1 ether / 1 wei); uint public constant DEVELOPERS_BONUS = 300000000 * (1 ether / 1 wei); uint public constant PRESALE_PRICE = 30000; // per 1 Ether uint public constant PRESALE_MAX_ETH = 2000; // 60 mln tokens sold during presale uint public constant PRESALE_TOKEN_SUPPLY_LIMIT = PRESALE_PRICE * PRESALE_MAX_ETH * (1 ether / 1 wei); uint public constant ICO_PRICE1 = 27500; // per 1 Ether uint public constant ICO_PRICE2 = 26250; // per 1 Ether uint public constant ICO_PRICE3 = 25000; // per 1 Ether // 1bln - this includes presale tokens uint public constant TOTAL_SOLD_TOKEN_SUPPLY_LIMIT = 1000000000* (1 ether / 1 wei); enum State{ Init, Paused, PresaleRunning, PresaleFinished, ICORunning, ICOFinished } State public currentState = State.Init; bool public enableTransfers = false; address public teamTokenBonus = 0; // Gathered funds can be withdrawn only to escrow's address. address public escrow = 0; // Token manager has exclusive priveleges to call administrative // functions on this contract. address public tokenManager = 0; uint public presaleSoldTokens = 0; uint public icoSoldTokens = 0; uint public totalSoldTokens = 0; /// Modifiers: modifier onlyTokenManager() { require(msg.sender==tokenManager); _; } modifier onlyInState(State state) { require(state==currentState); _; } /// Events: event LogBuy(address indexed owner, uint value); event LogBurn(address indexed owner, uint value); /// Functions: /// @dev Constructor /// @param _tokenManager Token manager address. function EthLendToken(address _tokenManager, address _escrow, address _teamTokenBonus) { tokenManager = _tokenManager; teamTokenBonus = _teamTokenBonus; escrow = _escrow; // send team bonus immediately uint teamBonus = DEVELOPERS_BONUS; balances[_teamTokenBonus] += teamBonus; supply+= teamBonus; assert(PRESALE_TOKEN_SUPPLY_LIMIT==60000000 * (1 ether / 1 wei)); assert(TOTAL_SOLD_TOKEN_SUPPLY_LIMIT==1000000000 * (1 ether / 1 wei)); } function buyTokens() public payable { require(currentState==State.PresaleRunning || currentState==State.ICORunning); if(currentState==State.PresaleRunning){ return buyTokensPresale(); }else{ return buyTokensICO(); } } function buyTokensPresale() public payable onlyInState(State.PresaleRunning) { // min - 1 ETH require(msg.value >= (1 ether / 1 wei)); uint newTokens = msg.value * PRESALE_PRICE; require(presaleSoldTokens + newTokens <= PRESALE_TOKEN_SUPPLY_LIMIT); balances[msg.sender] += newTokens; supply+= newTokens; presaleSoldTokens+= newTokens; totalSoldTokens+= newTokens; LogBuy(msg.sender, newTokens); } function buyTokensICO() public payable onlyInState(State.ICORunning) { // min - 0.01 ETH require(msg.value >= ((1 ether / 1 wei) / 100)); uint newTokens = msg.value * getPrice(); require(totalSoldTokens + newTokens <= TOTAL_SOLD_TOKEN_SUPPLY_LIMIT); balances[msg.sender] += newTokens; supply+= newTokens; icoSoldTokens+= newTokens; totalSoldTokens+= newTokens; LogBuy(msg.sender, newTokens); } function getPrice()constant returns(uint) { if(currentState==State.ICORunning){ if(icoSoldTokens<(200000000 * (1 ether / 1 wei))){ return ICO_PRICE1; } if(icoSoldTokens<(300000000 * (1 ether / 1 wei))){ return ICO_PRICE2; } return ICO_PRICE3; }else{ return PRESALE_PRICE; } } function setState(State _nextState) public onlyTokenManager { //setState() method call shouldn't be entertained after ICOFinished require(currentState != State.ICOFinished); currentState = _nextState; // enable/disable transfers //enable transfers only after ICOFinished, disable otherwise enableTransfers = (currentState==State.ICOFinished); } function withdrawEther() public onlyTokenManager { if(this.balance > 0) { require(escrow.send(this.balance)); } } /// Overrides: function transfer(address _to, uint256 _value) returns(bool){ require(enableTransfers); return super.transfer(_to,_value); } function transferFrom(address _from, address _to, uint256 _value) returns(bool){ require(enableTransfers); return super.transferFrom(_from,_to,_value); } function approve(address _spender, uint256 _value) returns (bool) { require(enableTransfers); return super.approve(_spender,_value); } /// Setters/getters function setTokenManager(address _mgr) public onlyTokenManager { tokenManager = _mgr; } // Default fallback function function() payable { buyTokens(); } }
247,450
11,838
a95787867f40b5a4f7e1c889a1b403f0aaa18b8155e4cba5373d1450c1e44cc5
19,476
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0x887e1988f7d697df22aea1207a5e1831ad3065ef.sol
4,579
17,816
pragma solidity ^0.4.18; // solhint-disable-line library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC721 { function approve(address _to, uint256 _tokenID) public; function balanceOf(address _owner) public view returns (uint256 balance); function implementsERC721() public pure returns (bool); function ownerOf(uint256 _tokenID) public view returns (address addr); function takeOwnership(uint256 _tokenID) public; function totalSupply() public view returns (uint256 total); function transferFrom(address _from, address _to, uint256 _tokenID) public; function transfer(address _to, uint256 _tokenID) public; event Transfer(address indexed from, address indexed to, uint256 tokenID); // solhint-disable-line event Approval(address indexed owner, address indexed approved, uint256 tokenID); function name() public pure returns (string); function symbol() public pure returns (string); } 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 Manageable is Ownable { address public manager; bool public contractLock; event ManagerTransferred(address indexed previousManager, address indexed newManager); event ContractLockChanged(address admin, bool state); function Manageable() public { manager = msg.sender; contractLock = false; } modifier onlyManager() { require(msg.sender == manager); _; } modifier onlyAdmin() { require((msg.sender == manager) || (msg.sender == owner)); _; } modifier isUnlocked() { require(!contractLock); _; } function transferManager(address newManager) public onlyAdmin { require(newManager != address(0)); ManagerTransferred(manager, newManager); manager = newManager; } function setContractLock(bool setting) public onlyAdmin { contractLock = setting; ContractLockChanged(msg.sender, setting); } function payout(address _to) public onlyOwner { if (_to == address(0)) { owner.transfer(this.balance); } else { _to.transfer(this.balance); } } function withdrawFunds(address _to, uint256 amount) public onlyOwner { require(this.balance >= amount); if (_to == address(0)) { owner.transfer(amount); } else { _to.transfer(amount); } } } contract TokenLayer is ERC721, Manageable { using SafeMath for uint256; event TokenCreated(uint256 tokenId, bytes32 name, uint256 parentId, address owner); event TokenDeleted(uint256 tokenId); event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, bytes32 name, uint256 parentId); event PriceChanged(uint256 tokenId, uint256 oldPrice, uint256 newPrice); event ParentChanged(uint256 tokenId, uint256 oldParentId, uint256 newParentId); event NameChanged(uint256 tokenId, bytes32 oldName, bytes32 newName); event MetaDataChanged(uint256 tokenId, bytes32 oldMeta, bytes32 newMeta); uint256 private constant DEFAULTPARENT = 123456789; mapping (uint256 => Token) private tokenIndexToToken; mapping (address => uint256) private ownershipTokenCount; address public gameAddress; address public parentAddr; uint256 private totalTokens; uint256 public devFee = 50; uint256 public ownerFee = 200; uint256[10] private chainFees = [10]; struct Token { bool exists; address approved; address owner; bytes32 metadata; bytes32 name; uint256 lastBlock; uint256 parentId; uint256 price; } modifier onlySystem() { require((msg.sender == gameAddress) || (msg.sender == manager)); _; } function TokenLayer(address _gameAddress, address _parentAddr) public { gameAddress = _gameAddress; parentAddr = _parentAddr; } function implementsERC721() public pure returns (bool) { return true; } function name() public pure returns (string) { return "CryptoJintori"; } function symbol() public pure returns (string) { return "JapanToken"; } function approve(address _to, uint256 _tokenId, address _from) public onlySystem { _approve(_to, _tokenId, _from); } function approve(address _to, uint256 _tokenId) public isUnlocked { _approve(_to, _tokenId, msg.sender); } function balanceOf(address _owner) public view returns (uint256 balance) { return ownershipTokenCount[_owner]; } function bundleToken(uint256 _tokenId) public view returns(uint256[8] _tokenData) { Token storage token = tokenIndexToToken[_tokenId]; uint256[8] memory tokenData; tokenData[0] = uint256(token.name); tokenData[1] = token.parentId; tokenData[2] = token.price; tokenData[3] = uint256(token.owner); tokenData[4] = _getNextPrice(_tokenId); tokenData[5] = devFee+getChainFees(_tokenId); tokenData[6] = uint256(token.approved); tokenData[7] = uint256(token.metadata); return tokenData; } function takeOwnership(uint256 _tokenId, address _to) public onlySystem { _takeOwnership(_tokenId, _to); } function takeOwnership(uint256 _tokenId) public isUnlocked { _takeOwnership(_tokenId, msg.sender); } function tokensOfOwner(address _owner) public view returns (uint256[] ownerTokens) { uint256 tokenCount = balanceOf(_owner); if (tokenCount == 0) { return new uint256[](0); } else { uint256[] memory result = new uint256[](tokenCount); uint256 _totalTokens = totalSupply(); uint256 resultIndex = 0; uint256 tokenId = 0; uint256 tokenIndex = 0; while (tokenIndex <= _totalTokens) { if (exists(tokenId)) { tokenIndex++; if (tokenIndexToToken[tokenId].owner == _owner) { result[resultIndex] = tokenId; resultIndex++; } } tokenId++; } return result; } } function totalSupply() public view returns (uint256 total) { return totalTokens; } function transfer(address _to, address _from, uint256 _tokenId) public onlySystem { _checkThenTransfer(_from, _to, _tokenId); } function transfer(address _to, uint256 _tokenId) public isUnlocked { _checkThenTransfer(msg.sender, _to, _tokenId); } function transferFrom(address _from, address _to, uint256 _tokenId) public onlySystem { _transferFrom(_from, _to, _tokenId); } function transferFrom(address _from, uint256 _tokenId) public isUnlocked { _transferFrom(_from, msg.sender, _tokenId); } function createToken(uint256 _tokenId, address _owner, bytes32 _name, uint256 _parentId, uint256 _price, bytes32 _metadata) public onlyAdmin { require(_price > 0); require(_addressNotNull(_owner)); require(_tokenId == uint256(uint32(_tokenId))); require(!exists(_tokenId)); totalTokens++; Token memory _token = Token({ name: _name, parentId: _parentId, exists: true, price: _price, owner: _owner, approved : 0, lastBlock : block.number, metadata : _metadata }); tokenIndexToToken[_tokenId] = _token; TokenCreated(_tokenId, _name, _parentId, _owner); _transfer(address(0), _owner, _tokenId); } function createTokens(uint256[] _tokenIds, address[] _owners, bytes32[] _names, uint256[] _parentIds, uint256[] _prices, bytes32[] _metadatas) public onlyAdmin { for (uint256 id = 0; id < _tokenIds.length; id++) { createToken(_tokenIds[id], _owners[id], _names[id], _parentIds[id], _prices[id], _metadatas[id]); } } function deleteToken(uint256 _tokenId) public onlyAdmin { require(_tokenId == uint256(uint32(_tokenId))); require(exists(_tokenId)); totalTokens--; address oldOwner = tokenIndexToToken[_tokenId].owner; ownershipTokenCount[oldOwner] = ownershipTokenCount[oldOwner]--; delete tokenIndexToToken[_tokenId]; TokenDeleted(_tokenId); } function incrementPrice(uint256 _tokenId, address _to) public onlySystem { require(exists(_tokenId)); uint256 _price = tokenIndexToToken[_tokenId].price; address _owner = tokenIndexToToken[_tokenId].owner; uint256 _totalFees = getChainFees(_tokenId); tokenIndexToToken[_tokenId].price = _price.mul(1000+ownerFee).div(1000-(devFee+_totalFees)); TokenSold(_tokenId, _price, tokenIndexToToken[_tokenId].price, _owner, _to, tokenIndexToToken[_tokenId].name, tokenIndexToToken[_tokenId].parentId); } function ownerOf(uint256 _tokenId) public view returns (address _owner) { require(exists(_tokenId)); _owner = tokenIndexToToken[_tokenId].owner; } function blocked(uint256 _tokenId) public view returns (bool _blocked) { return (tokenIndexToToken[_tokenId].lastBlock == block.number); } function exists(uint256 _tokenId) public view returns(bool) { return (tokenIndexToToken[_tokenId].exists); } function setLayerParent(address _parent) public onlyAdmin { parentAddr = _parent; } function setGame(address _gameAddress) public onlyAdmin { gameAddress = _gameAddress; } function setPrice(uint256 _tokenId, uint256 _price, address _owner) public onlySystem { require(_owns(_owner, _tokenId)); uint256 oldPrice = tokenIndexToToken[_tokenId].price; tokenIndexToToken[_tokenId].price = _price; PriceChanged(_tokenId, oldPrice, _price); } function setParent(uint256 _tokenId, uint256 _parentId) public onlyAdmin { require(exists(_tokenId)); uint256 oldParentId = tokenIndexToToken[_tokenId].parentId; tokenIndexToToken[_tokenId].parentId = _parentId; ParentChanged(_tokenId, oldParentId, _parentId); } function setName(uint256 _tokenId, bytes32 _name) public onlyAdmin { require(exists(_tokenId)); bytes32 oldName = tokenIndexToToken[_tokenId].name; tokenIndexToToken[_tokenId].name = _name; NameChanged(_tokenId, oldName, _name); } function setMetadata(uint256 _tokenId, bytes32 _metadata) public onlyAdmin { require(exists(_tokenId)); bytes32 oldMeta = tokenIndexToToken[_tokenId].metadata; tokenIndexToToken[_tokenId].metadata = _metadata; MetaDataChanged(_tokenId, oldMeta, _metadata); } function setDevFee(uint256 _devFee) public onlyAdmin { devFee = _devFee; } function setOwnerFee(uint256 _ownerFee) public onlyAdmin { ownerFee = _ownerFee; } function setChainFees(uint256[10] _chainFees) public onlyAdmin { chainFees = _chainFees; } function getToken(uint256 _tokenId) public view returns (bytes32 tokenName, uint256 parentId, uint256 price, address _owner, uint256 nextPrice, uint256 nextPriceFees, address approved, bytes32 metadata) { Token storage token = tokenIndexToToken[_tokenId]; tokenName = token.name; parentId = token.parentId; price = token.price; _owner = token.owner; nextPrice = _getNextPrice(_tokenId); nextPriceFees = devFee+getChainFees(_tokenId); metadata = token.metadata; approved = token.approved; } function getChainFees(uint256 _tokenId) public view returns (uint256 _total) { uint256 chainLength = _getChainLength(_tokenId); uint256 totalFee = 0; for (uint id = 0; id < chainLength; id++) { totalFee = totalFee + chainFees[id]; } return(totalFee); } function getChainFeeArray() public view returns (uint256[10] memory _chainFees) { return(chainFees); } function getPriceOf(uint256 _tokenId) public view returns (uint256 price) { require(exists(_tokenId)); return tokenIndexToToken[_tokenId].price; } function getParentOf(uint256 _tokenId) public view returns (uint256 parentId) { require(exists(_tokenId)); return tokenIndexToToken[_tokenId].parentId; } function getMetadataOf(uint256 _tokenId) public view returns (bytes32 metadata) { require(exists(_tokenId)); return (tokenIndexToToken[_tokenId].metadata); } function getChain(uint256 _tokenId) public view returns (address[10] memory _owners) { require(exists(_tokenId)); uint256 _parentId = getParentOf(_tokenId); address _parentAddr = parentAddr; address[10] memory result; if (_parentId != DEFAULTPARENT && _addressNotNull(_parentAddr)) { uint256 resultIndex = 0; TokenLayer layer = TokenLayer(_parentAddr); bool parentExists = layer.exists(_parentId); while ((_parentId != DEFAULTPARENT) && _addressNotNull(_parentAddr) && parentExists) { parentExists = layer.exists(_parentId); if (!parentExists) { return(result); } result[resultIndex] = layer.ownerOf(_parentId); resultIndex++; _parentId = layer.getParentOf(_parentId); _parentAddr = layer.parentAddr(); layer = TokenLayer(_parentAddr); } return(result); } } function _addressNotNull(address _to) private pure returns (bool) { return _to != address(0); } function _approved(address _to, uint256 _tokenId) private view returns (bool) { return (tokenIndexToToken[_tokenId].approved == _to); } function _owns(address claimant, uint256 _tokenId) private view returns (bool) { return claimant == tokenIndexToToken[_tokenId].owner; } function _checkThenTransfer(address _from, address _to, uint256 _tokenId) private { require(_owns(_from, _tokenId)); require(_addressNotNull(_to)); require(exists(_tokenId)); _transfer(_from, _to, _tokenId); } function _transfer(address _from, address _to, uint256 _tokenId) private { ownershipTokenCount[_to]++; tokenIndexToToken[_tokenId].owner = _to; tokenIndexToToken[_tokenId].lastBlock = block.number; if (_from != address(0)) { ownershipTokenCount[_from]--; tokenIndexToToken[_tokenId].approved = 0; } Transfer(_from, _to, _tokenId); } function _approve(address _to, uint256 _tokenId, address _from) private { require(_owns(_from, _tokenId)); tokenIndexToToken[_tokenId].approved = _to; Approval(_from, _to, _tokenId); } function _takeOwnership(uint256 _tokenId, address _to) private { address newOwner = _to; address oldOwner = tokenIndexToToken[_tokenId].owner; require(_addressNotNull(newOwner)); require(_approved(newOwner, _tokenId)); _transfer(oldOwner, newOwner, _tokenId); } function _transferFrom(address _from, address _to, uint256 _tokenId) private { require(_owns(_from, _tokenId)); require(_approved(_to, _tokenId)); require(_addressNotNull(_to)); _transfer(_from, _to, _tokenId); } function _getChainLength(uint256 _tokenId) private view returns (uint256 _length) { uint256 length; uint256 _parentId = getParentOf(_tokenId); address _parentAddr = parentAddr; if (_parentId == DEFAULTPARENT || !_addressNotNull(_parentAddr)) { return 0; } TokenLayer layer = TokenLayer(_parentAddr); bool parentExists = layer.exists(_parentId); while ((_parentId != DEFAULTPARENT) && _addressNotNull(_parentAddr) && parentExists) { parentExists = layer.exists(_parentId); if(!parentExists) { return(length); } _parentId = layer.getParentOf(_parentId); _parentAddr = layer.parentAddr(); layer = TokenLayer(_parentAddr); length++; } return(length); } function _getNextPrice(uint256 _tokenId) private view returns (uint256 _nextPrice) { uint256 _price = tokenIndexToToken[_tokenId].price; uint256 _totalFees = getChainFees(_tokenId); _price = _price.mul(1000+ownerFee).div(1000-(devFee+_totalFees)); return(_price); } }
145,477
11,839
67ad09aa528ac015ee339b5fcf0cc43b66c7016656d8ae85325913c2087406d8
16,090
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TX/TXb7ZeW4v4xwAyWcnj8wBT9TxnSeQhs3WV_TronCrown.sol
4,086
12,475
//SourceUnit: TronCrown.sol pragma solidity 0.5.17; 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 TronCrown { using SafeMath for uint256; uint256 constant public INVEST_MIN_AMOUNT = 200 trx; uint256 constant public BASE_PERCENT = 20; uint256 constant public MAX_HOLD_PERCENT = 5; uint256[] public REFERRAL_PERCENTS = [100,30, 20]; uint256 constant public MARKETING_FEE = 100; uint256 constant public PROJECT_FEE = 100; uint256 constant public PERCENTS_DIVIDER = 1000; uint256 constant public TIME_STEP = 24 hours; uint256 constant public LEADER_BONUS_STEP=5; uint256 constant public MAX_LEADER_PERCENT=5; uint256 public totalUsers; uint256 public totalInvested; uint256 public totalWithdrawn; uint256 public totalDeposits; address payable public marketingAddress; address payable public projectAddress; struct Deposit { uint256 amount; uint256 withdrawn; uint256 start; } struct User { Deposit[] deposits; uint256 checkpoint; address payable referrer; uint256 bonus; uint256 level1; uint256 level2; uint256 level3; uint256 refEarning; uint256 match_bonus; uint256 reinvested; uint256 withdrawn; } mapping (address => User) internal users; event Newbie(address user); event NewDeposit(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount); event FeePayed(address indexed user, uint256 totalAmount); constructor(address payable marketingAddr, address payable projectAddr) public { require(!isContract(marketingAddr) && !isContract(projectAddr)); marketingAddress = marketingAddr; projectAddress = projectAddr; } function invest(address payable referrer) public payable { require(msg.value >= INVEST_MIN_AMOUNT,"min amount is 200 Trx"); uint256 _amount=msg.value; marketingAddress.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER)); projectAddress.transfer(_amount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER)); emit FeePayed(msg.sender, _amount.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER)); User storage user = users[msg.sender]; if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) { user.referrer = referrer; } if (user.referrer != address(0)) { address upline = user.referrer; for (uint256 i = 0; i < 3; i++) { if (upline != address(0)) { uint256 amount = _amount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER); users[upline].bonus = users[upline].bonus.add(amount); if(i == 0){ users[upline].level1 = users[upline].level1.add(1); } else if(i == 1){ users[upline].level2 = users[upline].level2.add(1); } else if(i == 2){ users[upline].level3 = users[upline].level3.add(1); } emit RefBonus(upline, msg.sender, i, amount); upline = users[upline].referrer; } else break; } } if (user.deposits.length == 0) { user.checkpoint = block.timestamp; totalUsers = totalUsers.add(1); emit Newbie(msg.sender); } user.deposits.push(Deposit(_amount, 0, block.timestamp)); totalInvested = totalInvested.add(_amount); totalDeposits = totalDeposits.add(1); emit NewDeposit(msg.sender, _amount); } function ReInvest(address userAddress,uint256 amount) private { // require(amount >= INVEST_MIN_AMOUNT,"min amount is 200 Trx"); User storage user = users[userAddress]; user.deposits.push(Deposit(amount, 0, block.timestamp)); totalInvested = totalInvested.add(amount); totalDeposits = totalDeposits.add(1); emit NewDeposit(userAddress, amount); user.reinvested = user.reinvested.add(amount); } function withdraw() public { User storage user = users[msg.sender]; uint256 userPercentRate = getUserPercentRate(msg.sender); uint256 totalAmount; uint256 dividends; for (uint256 i = 0; i < user.deposits.length; i++) { if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3)) { if (user.deposits[i].start > user.checkpoint) { dividends = (user.deposits[i].amount.mul(BASE_PERCENT.add(userPercentRate)).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.deposits[i].start)) .div(TIME_STEP); } else { dividends = (user.deposits[i].amount.mul(BASE_PERCENT.add(userPercentRate)).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.checkpoint)) .div(TIME_STEP); } if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(3)) { dividends = (user.deposits[i].amount.mul(3)).sub(user.deposits[i].withdrawn); } user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data totalAmount = totalAmount.add(dividends); } } distributeRefBonus(msg.sender,totalAmount); uint256 referralBonus = getUserReferralBonus(msg.sender); if (referralBonus > 0) { totalAmount = totalAmount.add(referralBonus); user.bonus = 0; user.refEarning = user.refEarning.add(referralBonus); } if(user.match_bonus>0){ totalAmount= totalAmount.add(user.match_bonus); user.match_bonus = 0; } require(totalAmount > 0, "User has no dividends"); uint256 contractBalance = address(this).balance; require(contractBalance > totalAmount,"Contract Balance is lower"); user.withdrawn = user.withdrawn.add(totalAmount); ReInvest(msg.sender,totalAmount.mul(40).div(100)); user.checkpoint = block.timestamp; msg.sender.transfer(totalAmount.mul(60).div(100)); totalWithdrawn = totalWithdrawn.add(totalAmount.mul(60).div(100)); emit Withdrawn(msg.sender, totalAmount.mul(60).div(100)); } function distributeRefBonus(address userAddress,uint256 amount) private { for(uint256 i=0;i<10;i++) { address payable upline = users[userAddress].referrer; if(upline!=address(0)) { users[upline].match_bonus = users[upline].match_bonus.add(amount.mul(10).div(100)); userAddress = upline; } } } function getContractBalance() public view returns (uint256) { return address(this).balance; } function getUserPercentRate(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; if (isActive(userAddress)) { uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP); if (timeMultiplier > MAX_HOLD_PERCENT) { timeMultiplier = MAX_HOLD_PERCENT; } return timeMultiplier.add(getLeaderBonusRate(userAddress)); } else { return getLeaderBonusRate(userAddress); } } function getLeaderBonusRate(address userAddress) public view returns (uint) { uint leaderBonusPercent = users[userAddress].level1.div(LEADER_BONUS_STEP); if (leaderBonusPercent < MAX_LEADER_PERCENT) { return leaderBonusPercent; } else { return MAX_LEADER_PERCENT; } } function getUserDividends(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; uint userPercentRate = BASE_PERCENT.add(getUserPercentRate(msg.sender)); uint256 totalDividends; uint256 dividends; for (uint256 i = 0; i < user.deposits.length; i++) { if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(3)) { if (user.deposits[i].start > user.checkpoint) { dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.deposits[i].start)) .div(TIME_STEP); } else { dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.checkpoint)) .div(TIME_STEP); } if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(3)) { dividends = (user.deposits[i].amount.mul(3)).sub(user.deposits[i].withdrawn); } totalDividends = totalDividends.add(dividends); /// no update of withdrawn because that is view function } } return totalDividends; } 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) { User memory _user=users[userAddress]; return (_user.level1, _user.level2, _user.level3); } function getUserReferralBonus(address userAddress) public view returns(uint256) { return (users[userAddress].bonus); } function getUserMatchBonus(address userAddress) public view returns(uint256) { return (users[userAddress].match_bonus); } function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) { return getUserReferralBonus(userAddress).add(getUserDividends(userAddress)); } function isActive(address userAddress) public view returns (bool) { User storage user = users[userAddress]; if (user.deposits.length > 0) { if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) { return true; } } } function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) { User storage user = users[userAddress]; return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start); } function getUserAmountOfDeposits(address userAddress) public view returns(uint256) { return users[userAddress].deposits.length; } function getUserReinvested(address userAddress) public view returns(uint256) { return users[userAddress].reinvested; } function getUserRefEarnings(address userAddress) public view returns(uint256,uint256) { return (users[userAddress].refEarning,users[userAddress].withdrawn); } function getUserTotalDeposits(address userAddress) public view returns(uint256) { User storage user = users[userAddress]; uint256 amount; for (uint256 i = 0; i < user.deposits.length; i++) { amount = amount.add(user.deposits[i].amount); } return amount; } function getUserTotalWithdrawn(address userAddress) public view returns(uint256) { User storage user = users[userAddress]; uint256 amount; for (uint256 i = 0; i < user.deposits.length; i++) { amount = amount.add(user.deposits[i].withdrawn); } return amount; } function isContract(address addr) internal view returns (bool) { uint size; assembly { size := extcodesize(addr) } return size > 0; } function getHoldBonus(address userAddress) public view returns(uint256) { if(getUserCheckpoint(userAddress) == 0){ return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24); }else { return 0; } } }
288,788
11,840
fbbc63d16efec1b0411db15d493ed40c55770f74eadc2cc0326dc96080b2b2f3
18,408
.sol
Solidity
false
287517600
renardbebe/Smart-Contract-Benchmark-Suites
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
dataset/UR/0x20719b298fe7c486a9dca33d10759a6f3f7e1db9.sol
4,726
17,808
pragma solidity ^0.4.24; contract Token { function transfer(address _to, uint _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public view returns (uint256 remaining); function approve(address _spender, uint256 _value) public returns (bool success); function increaseApproval (address _spender, uint _addedValue) public returns (bool success); function balanceOf(address _owner) public view returns (uint256 balance); } contract Ownable { address public owner; modifier onlyOwner() { require(msg.sender == owner, "msg.sender is not the owner"); _; } constructor() public { owner = msg.sender; } function transferTo(address _to) external onlyOwner returns (bool) { require(_to != address(0), "Can't transfer to address 0x0"); owner = _to; return true; } } contract Oracle is Ownable { uint256 public constant VERSION = 4; event NewSymbol(bytes32 _currency); mapping(bytes32 => bool) public supported; bytes32[] public currencies; function url() public view returns (string); function getRate(bytes32 symbol, bytes data) public returns (uint256 rate, uint256 decimals); function addCurrency(string ticker) public onlyOwner returns (bool) { bytes32 currency = encodeCurrency(ticker); emit NewSymbol(currency); supported[currency] = true; currencies.push(currency); return true; } function encodeCurrency(string currency) public pure returns (bytes32 o) { require(bytes(currency).length <= 32, "Currency too long"); assembly { o := mload(add(currency, 32)) } } function decodeCurrency(bytes32 b) public pure returns (string o) { uint256 ns = 256; while (true) { if (ns == 0 || (b<<ns-8) != 0) break; ns -= 8; } assembly { ns := div(ns, 8) o := mload(0x40) mstore(0x40, add(o, and(add(add(ns, 0x20), 0x1f), not(0x1f)))) mstore(o, ns) mstore(add(o, 32), b) } } } contract Engine { uint256 public VERSION; string public VERSION_NAME; enum Status { initial, lent, paid, destroyed } struct Approbation { bool approved; bytes data; bytes32 checksum; } function getTotalLoans() public view returns (uint256); function getOracle(uint index) public view returns (Oracle); function getBorrower(uint index) public view returns (address); function getCosigner(uint index) public view returns (address); function ownerOf(uint256) public view returns (address owner); function getCreator(uint index) public view returns (address); function getAmount(uint index) public view returns (uint256); function getPaid(uint index) public view returns (uint256); function getDueTime(uint index) public view returns (uint256); function getApprobation(uint index, address _address) public view returns (bool); function getStatus(uint index) public view returns (Status); function isApproved(uint index) public view returns (bool); function getPendingAmount(uint index) public returns (uint256); function getCurrency(uint index) public view returns (bytes32); function cosign(uint index, uint256 cost) external returns (bool); function approveLoan(uint index) public returns (bool); function transfer(address to, uint256 index) public returns (bool); function takeOwnership(uint256 index) public returns (bool); function withdrawal(uint index, address to, uint256 amount) public returns (bool); function identifierToIndex(bytes32 signature) public view returns (uint256); } contract Cosigner { uint256 public constant VERSION = 2; function url() public view returns (string); function cost(address engine, uint256 index, bytes data, bytes oracleData) public view returns (uint256); function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool); function claim(address engine, uint256 index, bytes oracleData) public returns (bool); } contract TokenConverter { address public constant ETH_ADDRESS = 0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee; function getReturn(Token _fromToken, Token _toToken, uint256 _fromAmount) external view returns (uint256 amount); function convert(Token _fromToken, Token _toToken, uint256 _fromAmount, uint256 _minReturn) external payable returns (uint256 amount); } interface NanoLoanEngine { function pay(uint index, uint256 _amount, address _from, bytes oracleData) public returns (bool); function rcn() public view returns (Token); function getOracle(uint256 index) public view returns (Oracle); function getAmount(uint256 index) public view returns (uint256); function getCurrency(uint256 index) public view returns (bytes32); function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) public view returns (uint256); function lend(uint index, bytes oracleData, Cosigner cosigner, bytes cosignerData) public returns (bool); function transfer(address to, uint256 index) public returns (bool); function getPendingAmount(uint256 index) public returns (uint256); } library LrpSafeMath { function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) { uint256 z = x + y; require((z >= x) && (z >= y)); return z; } function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) { require(x >= y); uint256 z = x - y; return z; } function safeMult(uint256 x, uint256 y) internal pure returns(uint256) { uint256 z = x * y; require((x == 0)||(z/x == y)); return z; } function min(uint256 a, uint256 b) internal pure returns(uint256) { if (a < b) { return a; } else { return b; } } function max(uint256 a, uint256 b) internal pure returns(uint256) { if (a > b) { return a; } else { return b; } } } contract ConverterRamp is Ownable { using LrpSafeMath for uint256; address public constant ETH_ADDRESS = 0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee; uint256 public constant AUTO_MARGIN = 1000001; uint256 public constant I_MARGIN_SPEND = 0; uint256 public constant I_MAX_SPEND = 1; uint256 public constant I_REBUY_THRESHOLD = 2; uint256 public constant I_ENGINE = 0; uint256 public constant I_INDEX = 1; uint256 public constant I_PAY_AMOUNT = 2; uint256 public constant I_PAY_FROM = 3; uint256 public constant I_LEND_COSIGNER = 2; event RequiredRebuy(address token, uint256 amount); event Return(address token, address to, uint256 amount); event OptimalSell(address token, uint256 amount); event RequiredRcn(uint256 required); event RunAutoMargin(uint256 loops, uint256 increment); function pay(TokenConverter converter, Token fromToken, bytes32[4] loanParams, bytes oracleData, uint256[3] convertRules) external payable returns (bool) { Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn(); uint256 initialBalance = rcn.balanceOf(this); uint256 requiredRcn = getRequiredRcnPay(loanParams, oracleData); emit RequiredRcn(requiredRcn); uint256 optimalSell = getOptimalSell(converter, fromToken, rcn, requiredRcn, convertRules[I_MARGIN_SPEND]); emit OptimalSell(fromToken, optimalSell); pullAmount(fromToken, optimalSell); uint256 bought = convertSafe(converter, fromToken, rcn, optimalSell); require(executeOptimalPay({ params: loanParams, oracleData: oracleData, rcnToPay: bought }), "Error paying the loan"); require(rebuyAndReturn({ converter: converter, fromToken: rcn, toToken: fromToken, amount: rcn.balanceOf(this) - initialBalance, spentAmount: optimalSell, convertRules: convertRules }), "Error rebuying the tokens"); require(rcn.balanceOf(this) == initialBalance, "Converter balance has incremented"); return true; } function requiredLendSell(TokenConverter converter, Token fromToken, bytes32[3] loanParams, bytes oracleData, bytes cosignerData, uint256[3] convertRules) external view returns (uint256) { Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn(); return getOptimalSell(converter, fromToken, rcn, getRequiredRcnLend(loanParams, oracleData, cosignerData), convertRules[I_MARGIN_SPEND]); } function requiredPaySell(TokenConverter converter, Token fromToken, bytes32[4] loanParams, bytes oracleData, uint256[3] convertRules) external view returns (uint256) { Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn(); return getOptimalSell(converter, fromToken, rcn, getRequiredRcnPay(loanParams, oracleData), convertRules[I_MARGIN_SPEND]); } function lend(TokenConverter converter, Token fromToken, bytes32[3] loanParams, bytes oracleData, bytes cosignerData, uint256[3] convertRules) external payable returns (bool) { Token rcn = NanoLoanEngine(address(loanParams[I_ENGINE])).rcn(); uint256 initialBalance = rcn.balanceOf(this); uint256 requiredRcn = getRequiredRcnLend(loanParams, oracleData, cosignerData); emit RequiredRcn(requiredRcn); uint256 optimalSell = getOptimalSell(converter, fromToken, rcn, requiredRcn, convertRules[I_MARGIN_SPEND]); emit OptimalSell(fromToken, optimalSell); pullAmount(fromToken, optimalSell); uint256 bought = convertSafe(converter, fromToken, rcn, optimalSell); require(rcn.approve(address(loanParams[0]), bought), "Error approving lend token transfer"); require(executeLend(loanParams, oracleData, cosignerData), "Error lending the loan"); require(rcn.approve(address(loanParams[0]), 0), "Error removing approve"); require(executeTransfer(loanParams, msg.sender), "Error transfering the loan"); require(rebuyAndReturn({ converter: converter, fromToken: rcn, toToken: fromToken, amount: rcn.balanceOf(this) - initialBalance, spentAmount: optimalSell, convertRules: convertRules }), "Error rebuying the tokens"); require(rcn.balanceOf(this) == initialBalance, "The contract balance should not change"); return true; } function pullAmount(Token token, uint256 amount) private { if (token == ETH_ADDRESS) { require(msg.value >= amount, "Error pulling ETH amount"); if (msg.value > amount) { msg.sender.transfer(msg.value - amount); } } else { require(token.transferFrom(msg.sender, this, amount), "Error pulling Token amount"); } } function transfer(Token token, address to, uint256 amount) private { if (token == ETH_ADDRESS) { to.transfer(amount); } else { require(token.transfer(to, amount), "Error sending tokens"); } } function rebuyAndReturn(TokenConverter converter, Token fromToken, Token toToken, uint256 amount, uint256 spentAmount, uint256[3] memory convertRules) internal returns (bool) { uint256 threshold = convertRules[I_REBUY_THRESHOLD]; uint256 bought = 0; if (amount != 0) { if (amount > threshold) { bought = convertSafe(converter, fromToken, toToken, amount); emit RequiredRebuy(toToken, amount); emit Return(toToken, msg.sender, bought); transfer(toToken, msg.sender, bought); } else { emit Return(fromToken, msg.sender, amount); transfer(fromToken, msg.sender, amount); } } uint256 maxSpend = convertRules[I_MAX_SPEND]; require(spentAmount.safeSubtract(bought) <= maxSpend || maxSpend == 0, "Max spend exceeded"); return true; } function getOptimalSell(TokenConverter converter, Token fromToken, Token toToken, uint256 requiredTo, uint256 extraSell) internal returns (uint256 sellAmount) { uint256 sellRate = (10 ** 18 * converter.getReturn(toToken, fromToken, requiredTo)) / requiredTo; if (extraSell == AUTO_MARGIN) { uint256 expectedReturn = 0; uint256 optimalSell = applyRate(requiredTo, sellRate); uint256 increment = applyRate(requiredTo / 100000, sellRate); uint256 returnRebuy; uint256 cl; while (expectedReturn < requiredTo && cl < 10) { optimalSell += increment; returnRebuy = converter.getReturn(fromToken, toToken, optimalSell); optimalSell = (optimalSell * requiredTo) / returnRebuy; expectedReturn = returnRebuy; cl++; } emit RunAutoMargin(cl, increment); return optimalSell; } else { return applyRate(requiredTo, sellRate).safeMult(uint256(100000).safeAdd(extraSell)) / 100000; } } function convertSafe(TokenConverter converter, Token fromToken, Token toToken, uint256 amount) internal returns (uint256 bought) { if (fromToken != ETH_ADDRESS) require(fromToken.approve(converter, amount), "Error approving token transfer"); uint256 prevBalance = toToken != ETH_ADDRESS ? toToken.balanceOf(this) : address(this).balance; uint256 sendEth = fromToken == ETH_ADDRESS ? amount : 0; uint256 boughtAmount = converter.convert.value(sendEth)(fromToken, toToken, amount, 1); require(boughtAmount == (toToken != ETH_ADDRESS ? toToken.balanceOf(this) : address(this).balance) - prevBalance, "Bought amound does does not match"); if (fromToken != ETH_ADDRESS) require(fromToken.approve(converter, 0), "Error removing token approve"); return boughtAmount; } function executeOptimalPay(bytes32[4] memory params, bytes oracleData, uint256 rcnToPay) internal returns (bool) { NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE])); uint256 index = uint256(params[I_INDEX]); Oracle oracle = engine.getOracle(index); uint256 toPay; if (oracle == address(0)) { toPay = rcnToPay; } else { uint256 rate; uint256 decimals; bytes32 currency = engine.getCurrency(index); (rate, decimals) = oracle.getRate(currency, oracleData); toPay = (rcnToPay * (10 ** (18 - decimals + (18 * 2)) / rate)) / 10 ** 18; } Token rcn = engine.rcn(); require(rcn.approve(engine, rcnToPay), "Error on payment approve"); require(engine.pay(index, toPay, address(params[I_PAY_FROM]), oracleData), "Error paying the loan"); require(rcn.approve(engine, 0), "Error removing the payment approve"); return true; } function executeLend(bytes32[3] memory params, bytes oracleData, bytes cosignerData) internal returns (bool) { NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE])); uint256 index = uint256(params[I_INDEX]); return engine.lend(index, oracleData, Cosigner(address(params[I_LEND_COSIGNER])), cosignerData); } function executeTransfer(bytes32[3] memory params, address to) internal returns (bool) { return NanoLoanEngine(address(params[I_ENGINE])).transfer(to, uint256(params[1])); } function applyRate(uint256 amount, uint256 rate) internal pure returns (uint256) { return amount.safeMult(rate) / 10 ** 18; } function getRequiredRcnLend(bytes32[3] memory params, bytes oracleData, bytes cosignerData) internal view returns (uint256 required) { NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE])); uint256 index = uint256(params[I_INDEX]); Cosigner cosigner = Cosigner(address(params[I_LEND_COSIGNER])); if (cosigner != address(0)) { required += cosigner.cost(engine, index, cosignerData, oracleData); } required += engine.convertRate(engine.getOracle(index), engine.getCurrency(index), oracleData, engine.getAmount(index)); } function getRequiredRcnPay(bytes32[4] memory params, bytes oracleData) internal view returns (uint256) { NanoLoanEngine engine = NanoLoanEngine(address(params[I_ENGINE])); uint256 index = uint256(params[I_INDEX]); uint256 amount = uint256(params[I_PAY_AMOUNT]); return engine.convertRate(engine.getOracle(index), engine.getCurrency(index), oracleData, amount); } function withdrawTokens(Token _token, address _to, uint256 _amount) external onlyOwner returns (bool) { return _token.transfer(_to, _amount); } function withdrawEther(address _to, uint256 _amount) external onlyOwner { _to.transfer(_amount); } function() external payable {} }
166,865
11,841
950d9ada42f58e89074d58c5f225ff98da095685b25c1846b736f41aca472763
27,647
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/56/56bd8ff5B8c08B476fF8493110a056C19195def9_PiggyBankStaking.sol
4,335
17,218
// 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 sPB 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 sPB 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 IsPiggyBank { 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); } interface ReferralBonus { function getReferral(address _account) external view returns(address); function getRefBonus() external view returns(uint256); } contract PiggyBankStaking is Ownable { using SafeMath for uint256; using SafeMath for uint32; using SafeERC20 for IERC20; address public immutable PiggyBank; address public immutable sPiggyBank; 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 _PiggyBank, address _sPiggyBank, uint32 _epochLength, uint _firstEpochNumber, uint32 _firstEpochTime) { require(_PiggyBank != address(0)); PiggyBank = _PiggyBank; require(_sPiggyBank != address(0)); sPiggyBank = _sPiggyBank; 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(PiggyBank).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(IsPiggyBank(sPiggyBank).gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false }); IERC20(sPiggyBank).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, IsPiggyBank(sPiggyBank).balanceForGons(info.gons)); } } function forfeit() external { Claim memory info = warmupInfo[ msg.sender ]; delete warmupInfo[ msg.sender ]; IWarmup(warmupContract).retrieve(address(this), IsPiggyBank(sPiggyBank).balanceForGons(info.gons)); IERC20(PiggyBank).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(sPiggyBank).safeTransferFrom(msg.sender, address(this), _amount); IERC20(PiggyBank).safeTransfer(msg.sender, _amount); } function index() public view returns (uint) { return IsPiggyBank(sPiggyBank).index(); } function rebase() public { if(epoch.endTime <= uint32(block.timestamp)) { IsPiggyBank(sPiggyBank).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 = IsPiggyBank(sPiggyBank).circulatingSupply(); if(balance <= staked) { epoch.distribute = 0; } else { epoch.distribute = balance.sub(staked); } } } function contractBalance() public view returns (uint) { return IERC20(PiggyBank).balanceOf(address(this)).add(totalBonus); } function giveLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.add(_amount); IERC20(sPiggyBank).safeTransfer(locker, _amount); } function returnLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.sub(_amount); IERC20(sPiggyBank).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; } }
92,258
11,842
27e9a0f7ff2edd32fa10a5bdc39a87101711c983cace1701c899d1f39e5da207
13,624
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0xd5abcc4c80fd01d8822f35f379fbcebf7a8b8679.sol
2,864
12,526
pragma solidity ^0.4.6; /// @title Vault Contract /// @author Jordi Baylina /// @notice This contract holds funds for Campaigns and automates payments. For /// this iteration the funds will come straight from the Giveth Multisig as a /// safety precaution, but once fully tested and optimized this contract will /// be a safe place to store funds equipped with optional variable time delays /// to allow for an optional escape hatch /// @dev `Owned` is a base level contract that assigns an `owner` that can be /// later changed contract Owned { /// @dev `owner` is the only address that can call a function with this /// modifier modifier onlyOwner { if (msg.sender != owner) throw; _; } address public owner; /// @notice The Constructor assigns the message sender to be `owner` function Owned() { owner = msg.sender;} /// @notice `owner` can step down and assign some other address to this role /// @param _newOwner The address of the new owner. 0x0 can be used to create /// an unowned neutral vault, however that cannot be undone function changeOwner(address _newOwner) onlyOwner { owner = _newOwner; } } /// @dev `Escapable` is a base level contract built off of the `Owned` /// contract that creates an escape hatch function to send its ether to /// `escapeDestination` when called by the `escapeCaller` in the case that /// something unexpected happens contract Escapable is Owned { address public escapeCaller; address public escapeDestination; /// @notice The Constructor assigns the `escapeDestination` and the /// `escapeCaller` /// @param _escapeDestination The address of a safe location (usu a /// Multisig) to send the ether held in this contract /// @param _escapeCaller The address of a trusted account or contract to /// call `escapeHatch()` to send the ether in this contract to the /// `escapeDestination` it would be ideal that `escapeCaller` cannot move /// funds out of `escapeDestination` function Escapable(address _escapeCaller, address _escapeDestination) { escapeDestination = _escapeDestination; escapeCaller = _escapeCaller; } /// @dev The addresses preassigned the `escapeCaller` role /// is the only addresses that can call a function with this modifier modifier onlyEscapeCallerOrOwner { if ((msg.sender != escapeCaller)&&(msg.sender != owner)) throw; _; } /// @notice The `escapeHatch()` should only be called as a last resort if a /// security issue is uncovered or something unexpected happened function escapeHatch() onlyEscapeCallerOrOwner { uint total = this.balance; // Send the total balance of this contract to the `escapeDestination` if (!escapeDestination.send(total)) { throw; } EscapeCalled(total); } /// @notice Changes the address assigned to call `escapeHatch()` /// @param _newEscapeCaller The address of a trusted account or contract to /// call `escapeHatch()` to send the ether in this contract to the /// `escapeDestination` it would be ideal that `escapeCaller` cannot /// move funds out of `escapeDestination` function changeEscapeCaller(address _newEscapeCaller) onlyEscapeCallerOrOwner { escapeCaller = _newEscapeCaller; } event EscapeCalled(uint amount); } /// @dev `Vault` is a higher level contract built off of the `Escapable` /// contract that holds funds for Campaigns and automates payments. contract Vault is Escapable { /// @dev `Payment` is a public structure that describes the details of /// each payment making it easy to track the movement of funds /// transparently struct Payment { string description; // What is the purpose of this payment address spender; // Who is sending the funds uint earliestPayTime; // The earliest a payment can be made (Unix Time) bool canceled; // If True then the payment has been canceled bool paid; // If True then the payment has been paid address recipient; // Who is receiving the funds uint amount; // The amount of wei sent in the payment uint securityGuardDelay;// The seconds `securityGuard` can delay payment } Payment[] public authorizedPayments; address public securityGuard; uint public absoluteMinTimeLock; uint public timeLock; uint public maxSecurityGuardDelay; /// @dev The white list of approved addresses allowed to set up && receive /// payments from this vault mapping (address => bool) public allowedSpenders; /// @dev The address assigned the role of `securityGuard` is the only /// addresses that can call a function with this modifier modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; } // @dev Events to make the payment movements easy to find on the blockchain event PaymentAuthorized(uint idPayment, address recipient, uint amount); event PaymentExecuted(uint idPayment, address recipient, uint amount); event PaymentCanceled(uint idPayment); event EtherReceived(address from, uint amount); event SpenderAuthorization(address spender, bool authorized); ///////// // Constuctor ///////// /// @notice The Constructor creates the Vault on the blockchain /// @param _escapeCaller The address of a trusted account or contract to /// call `escapeHatch()` to send the ether in this contract to the /// `escapeDestination` it would be ideal if `escapeCaller` cannot move /// funds out of `escapeDestination` /// @param _escapeDestination The address of a safe location (usu a /// Multisig) to send the ether held in this contract in an emergency /// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can /// be set to, if set to 0 the `owner` can remove the `timeLock` completely /// @param _timeLock Initial number of seconds that payments are delayed /// after they are authorized (a security precaution) /// @param _securityGuard Address that will be able to delay the payments /// beyond the initial timelock requirements; can be set to 0x0 to remove /// the `securityGuard` functionality /// @param _maxSecurityGuardDelay The maximum number of seconds in total /// that `securityGuard` can delay a payment so that the owner can cancel /// the payment if needed function Vault(address _escapeCaller, address _escapeDestination, uint _absoluteMinTimeLock, uint _timeLock, address _securityGuard, uint _maxSecurityGuardDelay) Escapable(_escapeCaller, _escapeDestination) { securityGuard = _securityGuard; timeLock = _timeLock; absoluteMinTimeLock = _absoluteMinTimeLock; maxSecurityGuardDelay = _maxSecurityGuardDelay; } /// @notice States the total number of authorized payments in this contract function numberOfAuthorizedPayments() constant returns (uint) { return authorizedPayments.length; } ////// // Receive Ether ////// /// @notice Called anytime ether is sent to the contract && creates an event /// to more easily track the incoming transactions function receiveEther() payable { EtherReceived(msg.sender, msg.value); } /// @notice The fall back function is called whenever ether is sent to this /// contract function () payable { receiveEther(); } //////// // Spender Interface //////// /// @notice only `allowedSpenders[]` Creates a new `Payment` /// @param _description Brief description of the payment that is authorized /// @param _recipient Destination of the payment /// @param _amount Amount to be paid in wei /// @param _paymentDelay Number of seconds the payment is to be delayed, if /// this value is below `timeLock` then the `timeLock` determines the delay function authorizePayment(string _description, address _recipient, uint _amount, uint _paymentDelay) returns(uint) { // Fail if you arent on the `allowedSpenders` white list if (!allowedSpenders[msg.sender]) throw; uint idPayment = authorizedPayments.length; // Unique Payment ID authorizedPayments.length++; // The following lines fill out the payment struct Payment p = authorizedPayments[idPayment]; p.spender = msg.sender; // Determines the earliest the recipient can receive payment (Unix time) p.earliestPayTime = _paymentDelay >= timeLock ? now + _paymentDelay : now + timeLock; p.recipient = _recipient; p.amount = _amount; p.description = _description; PaymentAuthorized(idPayment, p.recipient, p.amount); return idPayment; } /// @notice only `allowedSpenders[]` The recipient of a payment calls this /// function to send themselves the ether after the `earliestPayTime` has /// expired /// @param _idPayment The payment ID to be executed function collectAuthorizedPayment(uint _idPayment) { // Check that the `_idPayment` has been added to the payments struct if (_idPayment >= authorizedPayments.length) throw; Payment p = authorizedPayments[_idPayment]; // Checking for reasons not to execute the payment if (msg.sender != p.recipient) throw; if (!allowedSpenders[p.spender]) throw; if (now < p.earliestPayTime) throw; if (p.canceled) throw; if (p.paid) throw; if (this.balance < p.amount) throw; p.paid = true; // Set the payment to being paid if (!p.recipient.send(p.amount)) { // Make the payment throw; } PaymentExecuted(_idPayment, p.recipient, p.amount); } ///////// // SecurityGuard Interface ///////// /// @notice `onlySecurityGuard` Delays a payment for a set number of seconds /// @param _idPayment ID of the payment to be delayed /// @param _delay The number of seconds to delay the payment function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard { if (_idPayment >= authorizedPayments.length) throw; Payment p = authorizedPayments[_idPayment]; if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) || (p.paid) || (p.canceled)) throw; p.securityGuardDelay += _delay; p.earliestPayTime += _delay; } //////// // Owner Interface /////// /// @notice `onlyOwner` Cancel a payment all together /// @param _idPayment ID of the payment to be canceled. function cancelPayment(uint _idPayment) onlyOwner { if (_idPayment >= authorizedPayments.length) throw; Payment p = authorizedPayments[_idPayment]; if (p.canceled) throw; if (p.paid) throw; p.canceled = true; PaymentCanceled(_idPayment); } /// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list /// @param _spender The address of the contract being authorized/unauthorized /// @param _authorize `true` if authorizing and `false` if unauthorizing function authorizeSpender(address _spender, bool _authorize) onlyOwner { allowedSpenders[_spender] = _authorize; SpenderAuthorization(_spender, _authorize); } /// @notice `onlyOwner` Sets the address of `securityGuard` /// @param _newSecurityGuard Address of the new security guard function setSecurityGuard(address _newSecurityGuard) onlyOwner { securityGuard = _newSecurityGuard; } /// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be /// lower than `absoluteMinTimeLock` /// @param _newTimeLock Sets the new minimum default `timeLock` in seconds; /// pending payments maintain their `earliestPayTime` function setTimelock(uint _newTimeLock) onlyOwner { if (_newTimeLock < absoluteMinTimeLock) throw; timeLock = _newTimeLock; } /// @notice `onlyOwner` Changes the maximum number of seconds /// `securityGuard` can delay a payment /// @param _maxSecurityGuardDelay The new maximum delay in seconds that /// `securityGuard` can delay the payment's execution in total function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyOwner { maxSecurityGuardDelay = _maxSecurityGuardDelay; } }
148,448
11,843
da82ff7765bdf40ec6a40df5b0fa411d67601427b67adb2ab5edb11a96c3c1b5
13,731
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/ae/Ae4799e0CA4C1AC972932a448D7F3dbB205Baf5B_MultiSigWallet.sol
2,984
12,969
pragma solidity ^0.5.17; /// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution. /// @author Stefan George - <[emailprotected]> contract MultiSigWallet { event Confirmation(address indexed sender, uint256 indexed transactionId); event Revocation(address indexed sender, uint256 indexed transactionId); event Submission(uint256 indexed transactionId); event Execution(uint256 indexed transactionId); event ExecutionFailure(uint256 indexed transactionId); event Deposit(address indexed sender, uint256 value); event OwnerAddition(address indexed owner); event OwnerRemoval(address indexed owner); event RequirementChange(uint256 required); uint256 constant public MAX_OWNER_COUNT = 50; mapping (uint256 => Transaction) public transactions; mapping (uint256 => mapping (address => bool)) public confirmations; mapping (address => bool) public isOwner; address[] public owners; uint256 public required; uint256 public transactionCount; struct Transaction { address destination; uint256 value; bytes data; bool executed; uint256 timestamp; } modifier onlyWallet() { require(msg.sender == address(this), "Only wallet"); _; } modifier ownerDoesNotExist(address owner) { require(!isOwner[owner], "Owner exists"); _; } modifier ownerExists(address owner) { require(isOwner[owner], "Owner does not exists"); _; } modifier transactionExists(uint256 transactionId) { require(transactions[transactionId].destination != address(0), "Tx doesn't exist"); _; } modifier confirmed(uint256 transactionId, address owner) { require(confirmations[transactionId][owner], "not confirmed"); _; } modifier notConfirmed(uint256 transactionId, address owner) { require(!confirmations[transactionId][owner], "is already confirmed"); _; } modifier notExecuted(uint256 transactionId) { require(!transactions[transactionId].executed, "tx already executed"); _; } modifier notNull(address _address) { require(_address != address(0), "address is null"); _; } modifier validRequirement(uint256 ownerCount, uint256 _required) { require(ownerCount <= MAX_OWNER_COUNT && _required <= ownerCount && _required != 0 && ownerCount != 0, "invalid requirement"); _; } /// @dev Fallback function allows to deposit ether. function() external payable { if (msg.value > 0) emit 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. constructor(address[] memory _owners, uint256 _required) public validRequirement(_owners.length, _required) { for (uint256 i = 0; i < _owners.length; i++) { require(!isOwner[_owners[i]] && _owners[i] != address(0), "is already owner"); 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 to add. function addOwner(address owner) public onlyWallet ownerDoesNotExist(owner) notNull(owner) validRequirement(owners.length + 1, required) { isOwner[owner] = true; owners.push(owner); emit OwnerAddition(owner); } /// @dev Allows to remove an owner. Transaction has to be sent by wallet. /// @param owner Address of owner to remove. function removeOwner(address owner) public onlyWallet ownerExists(owner) { isOwner[owner] = false; for (uint256 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); emit 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(uint256 i = 0; i < owners.length; i++) { if (owners[i] == owner) { owners[i] = newOwner; break; } } isOwner[owner] = false; isOwner[newOwner] = true; emit OwnerRemoval(owner); emit 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(uint256 _required) public onlyWallet validRequirement(owners.length, _required) { required = _required; emit 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, uint256 value, bytes memory data) public returns (uint256 transactionId) { transactionId = addTransaction(destination, value, data); confirmTransaction(transactionId); } /// @dev Allows an owner to confirm a transaction. /// @param transactionId Transaction ID. function confirmTransaction(uint256 transactionId) public ownerExists(msg.sender) transactionExists(transactionId) notConfirmed(transactionId, msg.sender) { confirmations[transactionId][msg.sender] = true; emit Confirmation(msg.sender, transactionId); executeTransaction(transactionId); } /// @dev Allows an owner to revoke a confirmation for a transaction. /// @param transactionId Transaction ID. function revokeConfirmation(uint256 transactionId) public ownerExists(msg.sender) confirmed(transactionId, msg.sender) notExecuted(transactionId) { confirmations[transactionId][msg.sender] = false; emit Revocation(msg.sender, transactionId); } /// @dev Allows anyone to execute a confirmed transaction. /// @param transactionId Transaction ID. function executeTransaction(uint256 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)) emit Execution(transactionId); else { emit 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, uint256 value, uint256 dataLength, bytes memory data) internal 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(uint256 transactionId) public view returns (bool) { uint256 count = 0; for (uint256 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, uint256 value, bytes memory data) internal notNull(destination) returns (uint256 transactionId) { transactionId = transactionCount; transactions[transactionId] = Transaction({ destination: destination, value: value, data: data, executed: false, timestamp: now }); transactionCount += 1; emit Submission(transactionId); } /// @dev Returns number of confirmations of a transaction. /// @param transactionId Transaction ID. /// @return Number of confirmations. function getConfirmationCount(uint256 transactionId) public view returns (uint256 count) { for (uint256 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 view returns (uint256 count) { for (uint256 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 view returns (address[] memory) { return owners; } /// @dev Returns array with owner addresses, which confirmed transaction. /// @param transactionId Transaction ID. /// @return Returns array of owner addresses. function getConfirmations(uint256 transactionId) public view returns (address[] memory _confirmations) { address[] memory confirmationsTemp = new address[](owners.length); uint256 count = 0; uint256 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(uint256 from, uint256 to, bool pending, bool executed) public view returns (uint256[] memory _transactionIds) { uint256[] memory transactionIdsTemp = new uint256[](transactionCount); uint256 count = 0; uint256 i; for (i = 0; i < transactionCount; i++) if (pending && !transactions[i].executed || executed && transactions[i].executed) { transactionIdsTemp[count] = i; count += 1; } _transactionIds = new uint256[](to - from); for (i = from; i < to; i++){ _transactionIds[i - from] = transactionIdsTemp[i]; } } function getTransaction(uint256 transactionId) public view returns (bytes memory, address, bool, uint256) { Transaction memory txn = transactions[transactionId]; return (txn.data, txn.destination, txn.executed, txn.timestamp); } }
312,095
11,844
9636da9c54f2cbde50357c9b441c41fd2f7e638844d69da2800aa126e8401287
7,609
.sol
Solidity
false
548668394
kodiasteerforth/Learn-Solidity-in-2-hours
20c453539af9a32e30ab1078b0301b3b207acc36
LearnSolidity.sol
2,012
7,272
// Solidity is a high-level programming language used to implement smart contracts. // SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.4; // Solidity version compiler // Interface - Talking to other SC without needing to have the complete code on chain interface IERC20 { function transferFrom(address _from, address _to, uint256 _value) external returns(bool success); } contract learnSolidity { // start with contract keyword and arbitrary name event Log(string message); function deposit(address _tokenAddress, uint _amount) public { // Deposit function interface IERC20(_tokenAddress).transferFrom(msg.sender, address(this), _amount); } // Data Types string public myString = "My string"; string public age; string public salute = "Hello World"; // Global Variables function paySent() public payable { require(msg.sender == tx.origin); // msg.sender = caller of function, tx.origin = origin of transaction amount = msg.value; // Amount of ether sent alongside the transaction } // Other types bool public boolean2 = false; uint public myUint = 2; int public myInt = -2; address public myAddress = 0xeb9A114797953fC9DEb0f91168661d15Cfd5Fc34; address private owner; uint public amount; // Arrays uint[] public array = [2, 3, 4]; uint[] public array1; uint[] public array2; string[] public array3 = ["pear", "berries", "avocado"]; // Visibility in solidity string private age1; // Only accesible inside the smart contract string internal age2; // Accesible inside smart contract but can be inherited string public age3; // Can be called inside/outside smart contract and also inherited // function visiblity function checkVisibility() public { // Can be called outside SC and called by another function } function checkVisibility1() private { // Cannot be called outside SC but can be called inside of another function in thesame SC } function checkVisibility2() external { // Can only be called outside the SC } function checkVisibility3() internal { // Can only be called inside the SM from another function } // function Modifiers function checkAge() public view returns (string memory) { // View function can read the state of the blockchain but cannot modify state return age; } function checkAge2() public pure returns(uint) { // Pure function cannot read the state of the blockchain nor modify state return 2; } function acceptPayment() public payable { // Payable functions are allowed to receive ether whenever transaction is submitted msg.value > tx.gasprice; } // Custom modifiers modifier onlyOwner { // This restricts who can call a specific function reserved for the owner require(msg.sender == owner, 'caller must be owner'); _; } // special function 'Constructor' is only called once whenever contract is put on the blockchain constructor(string memory _age) { age = _age; } // There are two types of functions in solidity write functions and read functions function setValue(string memory _age) public { // This is a write function so you have to pay a gas fee to call function age = _age; } function getValue() public view returns (string memory) { // While with the read function is completely free return age; } // Operators in solidity function eq(uint q, uint w) external pure returns(bool) { // Equal return q == w; } function notEq(uint q, uint w) external pure returns(bool) { // Not Equal return q != w; } function gT(uint q, uint w) external pure returns(bool) { // Greater than return q > w; } function lT(uint q, uint w) external pure returns(bool) { // Less than return q < w; } function gTEq2(uint q, uint w) external pure returns(bool) { // Greater than Equal to return q >= w; } function lTEq2(uint q, uint w) external pure returns(bool) { // Less than Equal to return q <= w; } function add(uint q, uint w) external pure returns(uint) { // Addition return q + w; } function sub(uint q, uint w) external pure returns(uint) { // Subtraction return q - w; } function div(uint q, uint w) external pure returns(uint) { // Division return q / w; } function mul(uint q, uint w) external pure returns(uint) { // Multiplication return q * w; } function exp(uint q, uint w) external pure returns(uint) { // Exponents return q ** w; } function mod(uint q, uint w) external pure returns(uint) { // Modulus return q % w; } function xor(uint q, uint w) external pure returns(uint) { // Bitwise Xor return q ^ w; } function inc(uint q) external pure returns(uint) { // Increment q++; return q; } function dec(uint q) external pure returns(uint) { // Decrement q--; return q; } function and(bool q, bool w) external pure returns(bool) { // And making sure both things are true return q && w; } function or(bool q, bool w) external pure returns(bool) { // Or either one of the variables is true return q || w; } function not(bool q) external pure returns(bool) { // Check if something is not true return !q; } function addExample() external pure returns(bool) { return (1+1 == 2) && (2+2 == 4); } // Conditionals in Solidity function evenOrOdd(uint q) public pure returns (string memory) { if(q % 2 == 0) { // if q % 2 == 0 return 'even', else return 'odd' return "even"; } else { return "odd"; } } function evenOrOdd1(uint q) public pure returns (string memory) { if(q % 2 == 0) { return "even"; } return "odd"; } function evenOrOdd2(uint q) public pure returns (string memory) { return q % 2 == 0 ? "even" : "odd"; } // Mappings - Key value pairs used to store information inside SC mapping(uint => address) public accountBalance; mapping(uint => string) public name; mapping(address => uint) public addresses; mapping(address => bool) public hasVoted; mapping(address => mapping(uint => bool)) public myMapping; // Nested mapping - mapping inside a mapping // Structs - Lets you create your own types struct structPacking { uint32 a; uint32 b; uint16 c; uint16 d; } // Ether - Native currency of the ethereum blockchain uint public value1 = 1 wei; uint public value2 = 2; uint public value3 = 1 gwei; uint public value4 = 1000000000; uint public value5 = 1 ether; uint public value6 = 1000000000000000000; receive() external payable{} // Can receive ether directly via a SC if you call it external payable function checkBalance() public view returns (uint) { // Can check balance of any address in SC like this return address(this).balance; } function transfer(address payable _to) public payable { // Sending ether to an address (bool sent,) = _to.call{value: msg.value}(""); require(sent, "Failed!"); } // Error Handling function example1(uint _amount) public { require(_amount > 10, "must be greater than 10"); emit Log("success"); } function example2(uint _amount) public { if(_amount <= 10) { revert("must be greater than 10"); } emit Log("success"); } // Events - Lets you subscribe externally to know whenever something has been called event SaluteUpdated(address indexed _user, string _salute); function updateSalute(string memory _salute) public { salute = _salute; emit SaluteUpdated(msg.sender, _salute); // Trigger event with the emit keyword } }
337,263
11,845
65fc0cbb7eef3fa9fbd5ec4c8df2a9421017248357188e9a09017aaf4a30e340
15,291
.sol
Solidity
false
606585904
plotchy/defi-detective
f48830b1085dac002283a2ce5e565e341aab5d0c
00byaddress/00cda8abd8a7193f69a1d54129ccd0b1fe61e53c.sol
3,767
13,452
// SPDX-License-Identifier: MIT pragma solidity 0.8.16; 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; address private _previousOwner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } } interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); } interface IUniswapV2Router02 { function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract DAIKOKU is Context, IERC20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private bots; mapping (address => uint) private cooldown; uint256 private constant MAX = ~uint256(0); uint256 private constant _tTotal = 1_000_000 * 10**8; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _feeAddr1; uint256 private _feeAddr2; uint256 private _initialTax; uint256 private _finalTax; uint256 private _reduceTaxCountdown; address payable private _feeAddrWallet; string private constant _name = "DAIKOKU"; string private constant _symbol = "DAIKOKU"; uint8 private constant _decimals = 8; IUniswapV2Router02 private uniswapV2Router; address private uniswapV2Pair; bool private tradingOpen; bool private inSwap = false; bool private swapEnabled = false; bool private cooldownEnabled = false; uint256 public _maxTxAmount = 20_000 * 10**8; uint256 public _maxWalletSize = 20_000 * 10**8; event MaxTxAmountUpdated(uint _maxTxAmount); modifier lockTheSwap { inSwap = true; _; inSwap = false; } constructor () { _feeAddrWallet = payable(_msgSender()); _rOwned[_msgSender()] = _rTotal; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[_feeAddrWallet] = true; _initialTax=4; _finalTax=2; _reduceTaxCountdown=60; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public pure returns (string memory) { return _name; } function symbol() public pure returns (string memory) { return _symbol; } function decimals() public pure returns (uint8) { return _decimals; } function totalSupply() public pure override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function setCooldownEnabled(bool onoff) external onlyOwner() { cooldownEnabled = onoff; } function tokenFromReflection(uint256 rAmount) private view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if (from != owner() && to != owner()) { require(!bots[from] && !bots[to]); _feeAddr1 = 0; _feeAddr2 = (_reduceTaxCountdown==0)?_finalTax:_initialTax; if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) { // Cooldown require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount."); require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); if(_reduceTaxCountdown>0){_reduceTaxCountdown--;} } uint256 contractTokenBalance = balanceOf(address(this)); if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0 && _reduceTaxCountdown<30) { swapTokensForEth(contractTokenBalance); uint256 contractETHBalance = address(this).balance; if(contractETHBalance > 0) { sendETHToFee(address(this).balance); } } }else{ _feeAddr1 = 0; _feeAddr2 = 0; } _tokenTransfer(from,to,amount); } function swapTokensForEth(uint256 tokenAmount) private lockTheSwap { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp); } function removeLimits() external onlyOwner{ _maxTxAmount = _tTotal; _maxWalletSize = _tTotal; } function sendETHToFee(uint256 amount) private { _feeAddrWallet.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 openTrading() external onlyOwner() { require(!tradingOpen,"trading is already open"); IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); uniswapV2Router = _uniswapV2Router; _approve(address(this), address(uniswapV2Router), _tTotal); uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH()); uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp); swapEnabled = true; cooldownEnabled = true; tradingOpen = true; IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max); } function _tokenTransfer(address sender, address recipient, uint256 amount) private { _transferStandard(sender, recipient, amount); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeTeam(tTeam); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _takeTeam(uint256 tTeam) private { uint256 currentRate = _getRate(); uint256 rTeam = tTeam.mul(currentRate); _rOwned[address(this)] = _rOwned[address(this)].add(rTeam); } function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } receive() external payable {} function manualswap() external { require(_msgSender() == _feeAddrWallet); uint256 contractBalance = balanceOf(address(this)); swapTokensForEth(contractBalance); } function manualsend() external { require(_msgSender() == _feeAddrWallet); uint256 contractETHBalance = address(this).balance; sendETHToFee(contractETHBalance); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = tAmount.mul(taxFee).div(100); uint256 tTeam = tAmount.mul(TeamFee).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam); return (tTransferAmount, tFee, tTeam); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rTeam = tTeam.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } }
343,861
11,846
8b5dc17e2b73ba9a472e01020007c2240ac77add2b177800de5988bec1cc9d14
15,426
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TP/TPVYdyQpqAdJdaGu1JkubRspbUCoHWzbLr_TronHighway.sol
3,579
13,898
//SourceUnit: TronHighway.sol pragma solidity 0.5.14; contract TronHighway { using SafeMath for uint; uint constant public DEPOSITS_MAX = 200; uint constant public INVEST_MIN_AMOUNT = 200 trx; uint constant public BASE_PERCENT = 500; uint constant private FUND_FEE = 1500; uint constant public MAX_CONTRACT_PERCENT = 1500; uint constant public MAX_HOLD_PERCENT = 1000; uint constant public MAX_DEPOSIT_PERCENT = 1500; uint constant public MAX_BALANCE_BONUS_PERCENT = 1000; uint constant public PERCENTS_DIVIDER = 10000; uint constant public CONTRACT_BALANCE_STEP = 250000 trx; uint constant public TIME_STEP = 1 days; uint[] public REFERRAL_PERCENTS = [500, 400, 300, 200, 100]; uint public totalDeposits; uint public totalInvested; uint public totalWithdrawn; uint public contractPercent; address payable public fundAddress; struct Deposit { uint64 amount; uint64 withdrawn; uint64 refback; uint32 start; } struct User { Deposit[] deposits; uint32 checkpoint; address referrer; uint64 bonus; uint24[5] refs; uint16 rbackPercent; } mapping (address => User) internal users; event Newbie(address user); event NewDeposit(address indexed user, uint amount); event Withdrawn(address indexed user, uint amount); event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount); event RefBack(address indexed referrer, address indexed referral, uint amount); event FeePayed(address indexed user, uint totalAmount); constructor(address payable fundAddr) public { require(!isContract(fundAddr)); fundAddress = fundAddr; contractPercent = getContractBalanceRate(); } function invest(address referrer) public payable { require(!isContract(msg.sender)); require(msg.value >= INVEST_MIN_AMOUNT, "Minimum deposit amount 200 TRX"); User storage user = users[msg.sender]; require(user.deposits.length < DEPOSITS_MAX, "Maximum 200 deposits from address"); uint fundFee = msg.value.mul(FUND_FEE).div(PERCENTS_DIVIDER); fundAddress.transfer(fundFee); if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) { user.referrer = referrer; } uint refbackAmount; if (user.referrer != address(0)) { address upline = user.referrer; for (uint i = 0; i < 5; i++) { if (upline != address(0)) { uint amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER); if (i == 0 && users[upline].rbackPercent > 0) { refbackAmount = amount.mul(uint(users[upline].rbackPercent)).div(PERCENTS_DIVIDER); msg.sender.transfer(refbackAmount); emit RefBack(upline, msg.sender, refbackAmount); amount = amount.sub(refbackAmount); } if (amount > 0) { address(uint160(upline)).transfer(amount); users[upline].bonus = uint64(uint(users[upline].bonus).add(amount)); emit RefBonus(upline, msg.sender, i, amount); } users[upline].refs[i]++; upline = users[upline].referrer; } else break; } } if (user.deposits.length == 0) { user.checkpoint = uint32(block.timestamp); emit Newbie(msg.sender); } user.deposits.push(Deposit(uint64(msg.value), 0, uint64(refbackAmount), uint32(block.timestamp))); totalInvested = totalInvested.add(msg.value); totalDeposits++; if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) { uint contractPercentNew = getContractBalanceRate(); if (contractPercentNew > contractPercent) { contractPercent = contractPercentNew; } } emit NewDeposit(msg.sender, msg.value); } function withdraw() public { User storage user = users[msg.sender]; uint userPercentRate = getUserPercentRate(msg.sender); uint totalAmount; uint dividends; for (uint i = 0; i < user.deposits.length; i++) { if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) { if (user.deposits[i].start > user.checkpoint) { dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(uint(user.deposits[i].start))) .div(TIME_STEP); } else { dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(uint(user.checkpoint))) .div(TIME_STEP); } if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) { dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn)); } user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data totalAmount = totalAmount.add(dividends); } } require(totalAmount > 0, "User has no dividends"); uint contractBalance = address(this).balance; if (contractBalance < totalAmount) { totalAmount = contractBalance; } user.checkpoint = uint32(block.timestamp); msg.sender.transfer(totalAmount); totalWithdrawn = totalWithdrawn.add(totalAmount); contractPercent = getContractBalanceRate(); emit Withdrawn(msg.sender, totalAmount); } function setRefback(uint16 rbackPercent) public { require(rbackPercent <= 10000); User storage user = users[msg.sender]; if (user.deposits.length > 0) { user.rbackPercent = rbackPercent; } } function getContractBalance() public view returns (uint) { return address(this).balance; } function getContractBalanceRate() public view returns (uint) { uint contractBalance = address(this).balance; uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20)); if (contractBalancePercent < MAX_CONTRACT_PERCENT) { return contractBalancePercent; } else { return MAX_CONTRACT_PERCENT; } } function getContractBalanceBonusRate() public view returns (uint){ uint contractBalance = address(this).balance; uint contractBalanceBonusRate = contractBalance.div(CONTRACT_BALANCE_STEP).mul(20); if (contractBalanceBonusRate < MAX_BALANCE_BONUS_PERCENT) { return contractBalanceBonusRate; } else { return MAX_BALANCE_BONUS_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).mul(20); if (timeMultiplier > MAX_HOLD_PERCENT) { timeMultiplier = MAX_HOLD_PERCENT; } if(contractPercent.add(timeMultiplier) > MAX_CONTRACT_PERCENT){ return MAX_CONTRACT_PERCENT; }else{ return contractPercent.add(timeMultiplier); } } else { return contractPercent; } } function getUserHoldBonusRate(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).mul(20); if(timeMultiplier < MAX_HOLD_PERCENT){ return timeMultiplier; }else { return MAX_HOLD_PERCENT; } }else { return 0; } } function getUserAvailable(address userAddress) public view returns (uint) { User storage user = users[userAddress]; uint userPercentRate = getUserPercentRate(userAddress); uint totalDividends; uint dividends; for (uint i = 0; i < user.deposits.length; i++) { if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) { if (user.deposits[i].start > user.checkpoint) { dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(uint(user.deposits[i].start))) .div(TIME_STEP); } else { dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(uint(user.checkpoint))) .div(TIME_STEP); } if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) { dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn)); } totalDividends = totalDividends.add(dividends); /// no update of withdrawn because that is view function } } return totalDividends; } function isActive(address userAddress) public view returns (bool) { User storage user = users[userAddress]; return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2); } function getUserAmountOfDeposits(address userAddress) public view returns (uint) { return users[userAddress].deposits.length; } function getUserTotalDeposits(address userAddress) public view returns (uint) { User storage user = users[userAddress]; uint amount; for (uint i = 0; i < user.deposits.length; i++) { amount = amount.add(uint(user.deposits[i].amount)); } return amount; } function getUserTotalWithdrawn(address userAddress) public view returns (uint) { User storage user = users[userAddress]; uint amount = user.bonus; for (uint i = 0; i < user.deposits.length; i++) { amount = amount.add(uint(user.deposits[i].withdrawn)).add(uint(user.deposits[i].refback)); } return amount; } function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) { User storage user = users[userAddress]; uint count = first.sub(last); if (count > user.deposits.length) { count = user.deposits.length; } uint[] memory amount = new uint[](count); uint[] memory withdrawn = new uint[](count); uint[] memory refback = new uint[](count); uint[] memory start = new uint[](count); uint index = 0; for (uint i = first; i > last; i--) { amount[index] = uint(user.deposits[i-1].amount); withdrawn[index] = uint(user.deposits[i-1].withdrawn); refback[index] = uint(user.deposits[i-1].refback); start[index] = uint(user.deposits[i-1].start); index++; } return (amount, withdrawn, refback, start); } function getSiteStats() public view returns (uint, uint, uint, uint) { uint contractBalanceBonusRate = getContractBalanceBonusRate(); return (totalInvested, totalDeposits, address(this).balance, contractBalanceBonusRate); } function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint, uint) { uint userPerc = getUserPercentRate(userAddress); uint userAvailable = getUserAvailable(userAddress); uint userDepsTotal = getUserTotalDeposits(userAddress); uint userDeposits = getUserAmountOfDeposits(userAddress); uint userWithdrawn = getUserTotalWithdrawn(userAddress); uint userHoldBonusRate = getUserHoldBonusRate(userAddress); return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn, userHoldBonusRate); } function getUserReferralsStats(address userAddress) public view returns (address, uint16, uint16, uint64, uint24[5] memory) { User storage user = users[userAddress]; return (user.referrer, user.rbackPercent, users[user.referrer].rbackPercent, user.bonus, user.refs); } function isContract(address addr) internal view returns (bool) { uint size; assembly { size := extcodesize(addr) } return size > 0; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); uint256 c = a / b; return c; } }
297,867
11,847
9fc7630aae6047e9af4d3182a5389a7e192fcbee5aa40307ae99495def5bd028
18,582
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0xb9131e894259d0d374bf189ca640ffc472a7d143.sol
4,577
17,200
pragma solidity ^0.4.11; contract SafeMath { function mul(uint a, uint b) constant internal returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint a, uint b) constant internal returns (uint) { assert(b != 0); // Solidity automatically throws when dividing by 0 uint c = a / b; assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint a, uint b) constant internal returns (uint) { assert(b <= a); return a - b; } function add(uint a, uint b) constant internal returns (uint) { uint c = a + b; assert(c >= a); return c; } // Volume bonus calculation function volumeBonus(uint etherValue) constant internal returns (uint) { if(etherValue >= 500000000000000000000) return 10; // 500 ETH +10% tokens if(etherValue >= 300000000000000000000) return 7; // 300 ETH +7% tokens if(etherValue >= 100000000000000000000) return 5; // 100 ETH +5% tokens if(etherValue >= 50000000000000000000) return 3; // 50 ETH +3% tokens if(etherValue >= 20000000000000000000) return 2; // 20 ETH +2% tokens if(etherValue >= 10000000000000000000) return 1; // 10 ETH +1% tokens return 0; } } /// Implements ERC 20 Token standard: https://github.com/ethereum/EIPs/issues/20 /// @title Abstract token contract - Functions to be implemented by token contracts. contract AbstractToken { function totalSupply() constant returns (uint) {} function balanceOf(address owner) constant returns (uint balance); function transfer(address to, uint value) returns (bool success); function transferFrom(address from, address to, uint value) returns (bool success); function approve(address spender, uint value) returns (bool success); function allowance(address owner, address spender) constant returns (uint remaining); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); event Issuance(address indexed to, uint value); } contract IcoLimits { uint constant privateSaleStart = 1511136000; // 11/20/2017 @ 12:00am (UTC) uint constant privateSaleEnd = 1512086399; // 11/30/2017 @ 11:59pm (UTC) uint constant presaleStart = 1512086400; // 12/01/2017 @ 12:00am (UTC) uint constant presaleEnd = 1513900799; // 12/21/2017 @ 11:59pm (UTC) uint constant publicSaleStart = 1516320000; // 01/19/2018 @ 12:00am (UTC) uint constant publicSaleEnd = 1521158399; // 03/15/2018 @ 11:59pm (UTC) modifier afterPublicSale() { require(now > publicSaleEnd); _; } uint constant privateSalePrice = 4000; // SNEK tokens per 1 ETH uint constant preSalePrice = 3000; // SNEK tokens per 1 ETH uint constant publicSalePrice = 2000; // SNEK tokens per 1 ETH uint constant privateSaleSupplyLimit = 600 * privateSalePrice * 1000000000000000000; uint constant preSaleSupplyLimit = 1200 * preSalePrice * 1000000000000000000; uint constant publicSaleSupplyLimit = 5000 * publicSalePrice * 1000000000000000000; } contract StandardToken is AbstractToken, IcoLimits { mapping (address => uint) balances; mapping (address => bool) ownerAppended; mapping (address => mapping (address => uint)) allowed; uint public totalSupply; address[] public owners; /// @dev Transfers sender's tokens to a given address. Returns success. /// @param _to Address of token receiver. /// @param _value Number of tokens to transfer. function transfer(address _to, uint _value) afterPublicSale returns (bool success) { if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[msg.sender] -= _value; balances[_to] += _value; if(!ownerAppended[_to]) { ownerAppended[_to] = true; owners.push(_to); } Transfer(msg.sender, _to, _value); return true; } else { return false; } } /// @dev Allows allowed third party to transfer tokens from one address to another. Returns success. /// @param _from Address from where tokens are withdrawn. /// @param _to Address to where tokens are sent. /// @param _value Number of tokens to transfer. function transferFrom(address _from, address _to, uint _value) afterPublicSale returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; if(!ownerAppended[_to]) { ownerAppended[_to] = true; owners.push(_to); } Transfer(_from, _to, _value); return true; } else { return false; } } /// @dev Returns number of tokens owned by given address. /// @param _owner Address of token owner. function balanceOf(address _owner) constant returns (uint balance) { return balances[_owner]; } /// @dev Sets approved amount of tokens for spender. Returns success. /// @param _spender Address of allowed account. /// @param _value Number of approved tokens. function approve(address _spender, uint _value) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } /// @dev Returns number of allowed tokens for given address. /// @param _owner Address of token owner. /// @param _spender Address of token spender. function allowance(address _owner, address _spender) constant returns (uint remaining) { return allowed[_owner][_spender]; } } contract ExoTownToken is StandardToken, SafeMath { string public constant name = "ExoTown token"; string public constant symbol = "SNEK"; uint public constant decimals = 18; address public icoContract = 0x0; modifier onlyIcoContract() { // only ICO contract is allowed to proceed require(msg.sender == icoContract); _; } /// @dev Contract is needed in icoContract address /// @param _icoContract Address of account which will be mint tokens function ExoTownToken(address _icoContract) { require(_icoContract != 0x0); icoContract = _icoContract; } /// @dev Burns tokens from address. It can be applied by account with address this.icoContract /// @param _from Address of account, from which will be burned tokens /// @param _value Amount of tokens, that will be burned function burnTokens(address _from, uint _value) onlyIcoContract { require(_value > 0); balances[_from] = sub(balances[_from], _value); totalSupply -= _value; } /// @dev Adds tokens to address. It can be applied by account with address this.icoContract /// @param _to Address of account to which the tokens will pass /// @param _value Amount of tokens function emitTokens(address _to, uint _value) onlyIcoContract { require(totalSupply + _value >= totalSupply); balances[_to] = add(balances[_to], _value); totalSupply += _value; if(!ownerAppended[_to]) { ownerAppended[_to] = true; owners.push(_to); } Transfer(0x0, _to, _value); } function getOwner(uint index) constant returns (address, uint) { return (owners[index], balances[owners[index]]); } function getOwnerCount() constant returns (uint) { return owners.length; } } contract ExoTownIco is SafeMath, IcoLimits { ExoTownToken public exotownToken; enum State { Pause, Running } State public currentState = State.Pause; uint public privateSaleSoldTokens = 0; uint public preSaleSoldTokens = 0; uint public publicSaleSoldTokens = 0; uint public privateSaleEtherRaised = 0; uint public preSaleEtherRaised = 0; uint public publicSaleEtherRaised = 0; // Address of manager address public icoManager; address public founderWallet; // Address from which tokens could be burned address public buyBack; // Purpose address public developmentWallet; address public marketingWallet; address public teamWallet; address public bountyOwner; // Mediator wallet is used for tracking user payments and reducing users' fee address public mediatorWallet; bool public sentTokensToBountyOwner = false; bool public sentTokensToFounders = false; modifier whenInitialized() { // only when contract is initialized require(currentState >= State.Running); _; } modifier onlyManager() { // only ICO manager can do this action require(msg.sender == icoManager); _; } modifier onIco() { require(isPrivateSale() || isPreSale() || isPublicSale()); _; } modifier hasBountyCampaign() { require(bountyOwner != 0x0); _; } function isPrivateSale() constant internal returns (bool) { return now >= privateSaleStart && now <= privateSaleEnd; } function isPreSale() constant internal returns (bool) { return now >= presaleStart && now <= presaleEnd; } function isPublicSale() constant internal returns (bool) { return now >= publicSaleStart && now <= publicSaleEnd; } function getPrice() constant internal returns (uint) { if (isPrivateSale()) return privateSalePrice; if (isPreSale()) return preSalePrice; if (isPublicSale()) return publicSalePrice; return publicSalePrice; } function getStageSupplyLimit() constant returns (uint) { if (isPrivateSale()) return privateSaleSupplyLimit; if (isPreSale()) return preSaleSupplyLimit; if (isPublicSale()) return publicSaleSupplyLimit; return 0; } function getStageSoldTokens() constant returns (uint) { if (isPrivateSale()) return privateSaleSoldTokens; if (isPreSale()) return preSaleSoldTokens; if (isPublicSale()) return publicSaleSoldTokens; return 0; } function addStageTokensSold(uint _amount) internal { if (isPrivateSale()) privateSaleSoldTokens = add(privateSaleSoldTokens, _amount); if (isPreSale()) preSaleSoldTokens = add(preSaleSoldTokens, _amount); if (isPublicSale()) publicSaleSoldTokens = add(publicSaleSoldTokens, _amount); } function addStageEtherRaised(uint _amount) internal { if (isPrivateSale()) privateSaleEtherRaised = add(privateSaleEtherRaised, _amount); if (isPreSale()) preSaleEtherRaised = add(preSaleEtherRaised, _amount); if (isPublicSale()) publicSaleEtherRaised = add(publicSaleEtherRaised, _amount); } function getStageEtherRaised() constant returns (uint) { if (isPrivateSale()) return privateSaleEtherRaised; if (isPreSale()) return preSaleEtherRaised; if (isPublicSale()) return publicSaleEtherRaised; return 0; } function getTokensSold() constant returns (uint) { return privateSaleSoldTokens + preSaleSoldTokens + publicSaleSoldTokens; } function getEtherRaised() constant returns (uint) { return privateSaleEtherRaised + preSaleEtherRaised + publicSaleEtherRaised; } /// @dev Constructor of ICO. Requires address of icoManager, /// @param _icoManager Address of ICO manager function ExoTownIco(address _icoManager) { require(_icoManager != 0x0); exotownToken = new ExoTownToken(this); icoManager = _icoManager; } /// Initialises addresses of founder, target wallets /// @param _founder Address of Founder /// @param _dev Address of Development wallet /// @param _pr Address of Marketing wallet /// @param _team Address of Team wallet /// @param _buyback Address of wallet used for burning tokens /// @param _mediator Address of Mediator wallet function init(address _founder, address _dev, address _pr, address _team, address _buyback, address _mediator) onlyManager { require(currentState == State.Pause); require(_founder != 0x0); require(_dev != 0x0); require(_pr != 0x0); require(_team != 0x0); require(_buyback != 0x0); require(_mediator != 0x0); founderWallet = _founder; developmentWallet = _dev; marketingWallet = _pr; teamWallet = _team; buyBack = _buyback; mediatorWallet = _mediator; currentState = State.Running; exotownToken.emitTokens(icoManager, 0); } /// @dev Sets new state /// @param _newState Value of new state function setState(State _newState) public onlyManager { currentState = _newState; } /// @dev Sets new manager. Only manager can do it /// @param _newIcoManager Address of new ICO manager function setNewManager(address _newIcoManager) onlyManager { require(_newIcoManager != 0x0); icoManager = _newIcoManager; } /// @dev Sets bounty owner. Only manager can do it /// @param _bountyOwner Address of Bounty owner function setBountyCampaign(address _bountyOwner) onlyManager { require(_bountyOwner != 0x0); bountyOwner = _bountyOwner; } /// @dev Sets new Mediator wallet. Only manager can do it /// @param _mediator Address of Mediator wallet function setNewMediator(address _mediator) onlyManager { require(_mediator != 0x0); mediatorWallet = _mediator; } /// @dev Buy quantity of tokens depending on the amount of sent ethers. /// @param _buyer Address of account which will receive tokens function buyTokens(address _buyer) private { require(_buyer != 0x0); require(msg.value > 0); uint tokensToEmit = msg.value * getPrice(); uint volumeBonusPercent = volumeBonus(msg.value); if (volumeBonusPercent > 0) { tokensToEmit = mul(tokensToEmit, 100 + volumeBonusPercent) / 100; } uint stageSupplyLimit = getStageSupplyLimit(); uint stageSoldTokens = getStageSoldTokens(); require(add(stageSoldTokens, tokensToEmit) <= stageSupplyLimit); exotownToken.emitTokens(_buyer, tokensToEmit); // Public statistics addStageTokensSold(tokensToEmit); addStageEtherRaised(msg.value); distributeEtherByStage(); } /// @dev Buy tokens to specified wallet function giftToken(address _to) public payable onIco { buyTokens(_to); } /// @dev Fall back function function () payable onIco { buyTokens(msg.sender); } function distributeEtherByStage() private { uint _balance = this.balance; uint _balance_div = _balance / 100; uint _devAmount = _balance_div * 65; uint _prAmount = _balance_div * 25; uint total = _devAmount + _prAmount; if (total > 0) { // Top up Mediator wallet with 1% of Development amount = 0.65% of contribution amount. // It will cover tracking transaction fee (if any). // See White Paper for more information about payment tracking uint _mediatorAmount = _devAmount / 100; mediatorWallet.transfer(_mediatorAmount); developmentWallet.transfer(_devAmount - _mediatorAmount); marketingWallet.transfer(_prAmount); teamWallet.transfer(_balance - _devAmount - _prAmount); } } /// @dev Partial withdraw. Only manager can do it function withdrawEther(uint _value) onlyManager { require(_value > 0); require(_value <= this.balance); // send 1234 to get 1.234 icoManager.transfer(_value * 1000000000000000); // 10^15 } function sendTokensToBountyOwner() onlyManager whenInitialized hasBountyCampaign afterPublicSale { require(!sentTokensToBountyOwner); //Calculate bounty tokens depending on total tokens sold uint bountyTokens = getTokensSold() / 40; // 2.5% exotownToken.emitTokens(bountyOwner, bountyTokens); sentTokensToBountyOwner = true; } /// @dev Send tokens to founders. function sendTokensToFounders() onlyManager whenInitialized afterPublicSale { require(!sentTokensToFounders); //Calculate founder reward depending on total tokens sold uint founderReward = getTokensSold() / 10; // 10% exotownToken.emitTokens(founderWallet, founderReward); sentTokensToFounders = true; } // Anyone could burn tokens by sending it to buyBack address and calling this function. function burnTokens(uint _amount) afterPublicSale { exotownToken.burnTokens(buyBack, _amount); } }
140,440
11,848
a34a287b3882fc1707ae5143dccdbff26cf069b50d19f322e48536746498814b
31,821
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/cf/cFEC71a2A53cCc9a543322bd80fEd796a7cf41A6_Masonry.sol
4,859
18,672
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ContractGuard { mapping(uint256 => mapping(address => bool)) private _status; function checkSameOriginReentranted() internal view returns (bool) { return _status[block.number][tx.origin]; } function checkSameSenderReentranted() internal view returns (bool) { return _status[block.number][msg.sender]; } modifier onlyOneBlock() { require(!checkSameOriginReentranted(), "ContractGuard: one block, one function"); require(!checkSameSenderReentranted(), "ContractGuard: one block, one function"); _; _status[block.number][tx.origin] = true; _status[block.number][msg.sender] = true; } } interface IBasisAsset { function mint(address recipient, uint256 amount) external returns (bool); function burn(uint256 amount) external; function burnFrom(address from, uint256 amount) external; function isOperator() external returns (bool); function operator() external view returns (address); function transferOperator(address newOperator_) external; } interface ITreasury { function epoch() external view returns (uint256); function nextEpochPoint() external view returns (uint256); function getGhostPrice() external view returns (uint256); function buyBonds(uint256 amount, uint256 targetPrice) external; function redeemBonds(uint256 amount, uint256 targetPrice) external; } contract ShareWrapper { using SafeMath for uint256; using SafeERC20 for IERC20; IERC20 public share; uint256 private _totalSupply; mapping(address => uint256) private _balances; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function stake(uint256 amount) public virtual { _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); share.safeTransferFrom(msg.sender, address(this), amount); } function withdraw(uint256 amount) public virtual { uint256 masonShare = _balances[msg.sender]; require(masonShare >= amount, "Masonry: withdraw request greater than staked amount"); _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = masonShare.sub(amount); share.safeTransfer(msg.sender, amount); } } contract Masonry is ShareWrapper, ContractGuard { using SafeERC20 for IERC20; using Address for address; using SafeMath for uint256; struct Masonseat { uint256 lastSnapshotIndex; uint256 rewardEarned; uint256 epochTimerStart; } struct MasonrySnapshot { uint256 time; uint256 rewardReceived; uint256 rewardPerShare; } // governance address public operator; // flags bool public initialized = false; IERC20 public ghost; ITreasury public treasury; mapping(address => Masonseat) public masons; MasonrySnapshot[] public masonryHistory; uint256 public withdrawLockupEpochs; uint256 public rewardLockupEpochs; event Initialized(address indexed executor, uint256 at); event Staked(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); event RewardAdded(address indexed user, uint256 reward); modifier onlyOperator() { require(operator == msg.sender, "Masonry: caller is not the operator"); _; } modifier masonExists { require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist"); _; } modifier updateReward(address mason) { if (mason != address(0)) { Masonseat memory seat = masons[mason]; seat.rewardEarned = earned(mason); seat.lastSnapshotIndex = latestSnapshotIndex(); masons[mason] = seat; } _; } modifier notInitialized { require(!initialized, "Masonry: already initialized"); _; } function initialize(IERC20 _ghost, IERC20 _share, ITreasury _treasury) public notInitialized { ghost = _ghost; share = _share; treasury = _treasury; MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0}); masonryHistory.push(genesisSnapshot); withdrawLockupEpochs = 3; // Lock for 6 epochs (36h) before release withdraw rewardLockupEpochs = 1; // Lock for 3 epochs (18h) before release claimReward initialized = true; operator = msg.sender; emit Initialized(msg.sender, block.number); } function setOperator(address _operator) external onlyOperator { operator = _operator; } function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator { require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week withdrawLockupEpochs = _withdrawLockupEpochs; rewardLockupEpochs = _rewardLockupEpochs; } // =========== Snapshot getters function latestSnapshotIndex() public view returns (uint256) { return masonryHistory.length.sub(1); } function getLatestSnapshot() internal view returns (MasonrySnapshot memory) { return masonryHistory[latestSnapshotIndex()]; } function getLastSnapshotIndexOf(address mason) public view returns (uint256) { return masons[mason].lastSnapshotIndex; } function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) { return masonryHistory[getLastSnapshotIndexOf(mason)]; } function canWithdraw(address mason) external view returns (bool) { return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(); } function canClaimReward(address mason) external view returns (bool) { return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(); } function epoch() external view returns (uint256) { return treasury.epoch(); } function nextEpochPoint() external view returns (uint256) { return treasury.nextEpochPoint(); } function getGhostPrice() external view returns (uint256) { return treasury.getGhostPrice(); } // =========== Mason getters function rewardPerShare() public view returns (uint256) { return getLatestSnapshot().rewardPerShare; } function earned(address mason) public view returns (uint256) { uint256 latestRPS = getLatestSnapshot().rewardPerShare; uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare; return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned); } function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) { require(amount > 0, "Masonry: Cannot stake 0"); super.stake(amount); masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer emit Staked(msg.sender, amount); } function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) { require(amount > 0, "Masonry: Cannot withdraw 0"); require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup"); claimReward(); super.withdraw(amount); emit Withdrawn(msg.sender, amount); } function exit() external { withdraw(balanceOf(msg.sender)); } function claimReward() public updateReward(msg.sender) { uint256 reward = masons[msg.sender].rewardEarned; if (reward > 0) { require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup"); masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer masons[msg.sender].rewardEarned = 0; ghost.safeTransfer(msg.sender, reward); emit RewardPaid(msg.sender, reward); } } function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator { require(amount > 0, "Masonry: Cannot allocate 0"); require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0"); // Create & add new snapshot uint256 prevRPS = getLatestSnapshot().rewardPerShare; uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply())); MasonrySnapshot memory newSnapshot = MasonrySnapshot({ time: block.number, rewardReceived: amount, rewardPerShare: nextRPS }); masonryHistory.push(newSnapshot); ghost.safeTransferFrom(msg.sender, address(this), amount); emit RewardAdded(msg.sender, amount); } function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator { // do not allow to drain core tokens require(address(_token) != address(ghost), "ghost"); require(address(_token) != address(share), "share"); _token.safeTransfer(_to, _amount); } }
71,489
11,849
9ebc011c5360b7bae004e95dab42767bc0aa3dd8c844efa344ba20fb48a64bfd
20,636
.sol
Solidity
false
360539372
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
1d65472e1c546af6781cb17991843befc635a28e
dataset/dapp_contracts/Exchange/0x818E6FECD516Ecc3849DAf6845e3EC868087B755.sol
4,476
18,815
pragma solidity 0.4.18; // File: contracts/ERC20Interface.sol // https://github.com/ethereum/EIPs/issues/20 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); } // File: contracts/KyberNetworkInterface.sol /// @title Kyber Network interface interface KyberNetworkInterface { function maxGasPrice() public view returns(uint); function getUserCapInWei(address user) public view returns(uint); function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint); function enabled() public view returns(bool); function info(bytes32 id) public view returns(uint); function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view returns (uint expectedRate, uint slippageRate); function tradeWithHint(address trader, ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) public payable returns(uint); } // File: contracts/KyberNetworkProxyInterface.sol /// @title Kyber Network interface interface KyberNetworkProxyInterface { function maxGasPrice() public view returns(uint); function getUserCapInWei(address user) public view returns(uint); function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint); function enabled() public view returns(bool); function info(bytes32 id) public view returns(uint); function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view returns (uint expectedRate, uint slippageRate); function tradeWithHint(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) public payable returns(uint); } // File: contracts/SimpleNetworkInterface.sol /// @title simple interface for Kyber Network interface SimpleNetworkInterface { function swapTokenToToken(ERC20 src, uint srcAmount, ERC20 dest, uint minConversionRate) public returns(uint); function swapEtherToToken(ERC20 token, uint minConversionRate) public payable returns(uint); function swapTokenToEther(ERC20 token, uint srcAmount, uint minConversionRate) public returns(uint); } // File: contracts/Utils.sol /// @title Kyber constants contract 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 } } // File: contracts/Utils2.sol contract Utils2 is Utils { /// @dev get the balance of a user. /// @param token The token type /// @return The balance function getBalance(ERC20 token, address user) public view returns(uint) { if (token == ETH_TOKEN_ADDRESS) return user.balance; else return token.balanceOf(user); } function getDecimalsSafe(ERC20 token) internal returns(uint) { if (decimals[token] == 0) { setDecimals(token); } return decimals[token]; } function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) { return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate); } function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) { return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate); } function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals) internal pure returns(uint) { require(srcAmount <= MAX_QTY); require(destAmount <= MAX_QTY); if (dstDecimals >= srcDecimals) { require((dstDecimals - srcDecimals) <= MAX_DECIMALS); return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount)); } else { require((srcDecimals - dstDecimals) <= MAX_DECIMALS); return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount); } } } // File: contracts/PermissionGroups.sol 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; } } } } // File: contracts/Withdrawable.sol 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); } } // File: contracts/KyberNetworkProxy.sol /// @title Kyber Network proxy for main contract contract KyberNetworkProxy is KyberNetworkProxyInterface, SimpleNetworkInterface, Withdrawable, Utils2 { KyberNetworkInterface public kyberNetworkContract; function KyberNetworkProxy(address _admin) public { require(_admin != address(0)); admin = _admin; } /// @notice use token address ETH_TOKEN_ADDRESS for ether /// @dev makes a trade between src and dest token and send dest token to destAddress /// @param src Src token /// @param srcAmount amount of src tokens /// @param dest Destination token /// @param destAddress Address to send tokens to /// @param maxDestAmount A limit on the amount of dest tokens /// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled. /// @param walletId is the wallet ID to send part of the fees /// @return amount of actual dest tokens function trade(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId) public payable returns(uint) { bytes memory hint; return tradeWithHint(src, srcAmount, dest, destAddress, maxDestAmount, minConversionRate, walletId, hint); } /// @dev makes a trade between src and dest token and send dest tokens to msg sender /// @param src Src token /// @param srcAmount amount of src tokens /// @param dest Destination token /// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled. /// @return amount of actual dest tokens function swapTokenToToken(ERC20 src, uint srcAmount, ERC20 dest, uint minConversionRate) public returns(uint) { bytes memory hint; return tradeWithHint(src, srcAmount, dest, msg.sender, MAX_QTY, minConversionRate, 0, hint); } /// @dev makes a trade from Ether to token. Sends token to msg sender /// @param token Destination token /// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled. /// @return amount of actual dest tokens function swapEtherToToken(ERC20 token, uint minConversionRate) public payable returns(uint) { bytes memory hint; return tradeWithHint(ETH_TOKEN_ADDRESS, msg.value, token, msg.sender, MAX_QTY, minConversionRate, 0, hint); } /// @dev makes a trade from token to Ether, sends Ether to msg sender /// @param token Src token /// @param srcAmount amount of src tokens /// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled. /// @return amount of actual dest tokens function swapTokenToEther(ERC20 token, uint srcAmount, uint minConversionRate) public returns(uint) { bytes memory hint; return tradeWithHint(token, srcAmount, ETH_TOKEN_ADDRESS, msg.sender, MAX_QTY, minConversionRate, 0, hint); } struct UserBalance { uint srcBalance; uint destBalance; } event ExecuteTrade(address indexed trader, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount); /// @notice use token address ETH_TOKEN_ADDRESS for ether /// @dev makes a trade between src and dest token and send dest token to destAddress /// @param src Src token /// @param srcAmount amount of src tokens /// @param dest Destination token /// @param destAddress Address to send tokens to /// @param maxDestAmount A limit on the amount of dest tokens /// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled. /// @param walletId is the wallet ID to send part of the fees /// @param hint will give hints for the trade. /// @return amount of actual dest tokens function tradeWithHint(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId, bytes hint) public payable returns(uint) { require(src == ETH_TOKEN_ADDRESS || msg.value == 0); UserBalance memory userBalanceBefore; userBalanceBefore.srcBalance = getBalance(src, msg.sender); userBalanceBefore.destBalance = getBalance(dest, destAddress); if (src == ETH_TOKEN_ADDRESS) { userBalanceBefore.srcBalance += msg.value; } else { require(src.transferFrom(msg.sender, kyberNetworkContract, srcAmount)); } uint reportedDestAmount = kyberNetworkContract.tradeWithHint.value(msg.value)(msg.sender, src, srcAmount, dest, destAddress, maxDestAmount, minConversionRate, walletId, hint); TradeOutcome memory tradeOutcome = calculateTradeOutcome(userBalanceBefore.srcBalance, userBalanceBefore.destBalance, src, dest, destAddress); require(reportedDestAmount == tradeOutcome.userDeltaDestAmount); require(tradeOutcome.userDeltaDestAmount <= maxDestAmount); require(tradeOutcome.actualRate >= minConversionRate); ExecuteTrade(msg.sender, src, dest, tradeOutcome.userDeltaSrcAmount, tradeOutcome.userDeltaDestAmount); return tradeOutcome.userDeltaDestAmount; } event KyberNetworkSet(address newNetworkContract, address oldNetworkContract); function setKyberNetworkContract(KyberNetworkInterface _kyberNetworkContract) public onlyAdmin { require(_kyberNetworkContract != address(0)); KyberNetworkSet(_kyberNetworkContract, kyberNetworkContract); kyberNetworkContract = _kyberNetworkContract; } function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view returns(uint expectedRate, uint slippageRate) { return kyberNetworkContract.getExpectedRate(src, dest, srcQty); } function getUserCapInWei(address user) public view returns(uint) { return kyberNetworkContract.getUserCapInWei(user); } function getUserCapInTokenWei(address user, ERC20 token) public view returns(uint) { return kyberNetworkContract.getUserCapInTokenWei(user, token); } function maxGasPrice() public view returns(uint) { return kyberNetworkContract.maxGasPrice(); } function enabled() public view returns(bool) { return kyberNetworkContract.enabled(); } function info(bytes32 field) public view returns(uint) { return kyberNetworkContract.info(field); } struct TradeOutcome { uint userDeltaSrcAmount; uint userDeltaDestAmount; uint actualRate; } function calculateTradeOutcome (uint srcBalanceBefore, uint destBalanceBefore, ERC20 src, ERC20 dest, address destAddress) internal returns(TradeOutcome outcome) { uint userSrcBalanceAfter; uint userDestBalanceAfter; userSrcBalanceAfter = getBalance(src, msg.sender); userDestBalanceAfter = getBalance(dest, destAddress); //protect from underflow require(userDestBalanceAfter > destBalanceBefore); require(srcBalanceBefore > userSrcBalanceAfter); outcome.userDeltaDestAmount = userDestBalanceAfter - destBalanceBefore; outcome.userDeltaSrcAmount = srcBalanceBefore - userSrcBalanceAfter; outcome.actualRate = calcRateFromQty(outcome.userDeltaSrcAmount, outcome.userDeltaDestAmount, getDecimalsSafe(src), getDecimalsSafe(dest)); } }
336,278
11,850
79ada9bbf056b67eaff90ce870e002b1c751376a06a1c1063e214e46428de219
23,974
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
src/securityAbandonerAndInjector/NonpublicVarAccessdByPublicFunc/manualCheck/0x0d93a7028c7cb9a1014917d52747c9bc210325cd_nonpublicVarAccessdByPublicFunc.sol
4,448
16,927
pragma solidity ^0.5.16; // Subject to the MIT license. library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, errorMessage); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction underflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, errorMessage); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } contract Unicorn { /// @notice EIP-20 token name for this token string internal constant name = "Unicorn"; /// @notice EIP-20 token symbol for this token string public constant symbol = "UNIC"; /// @notice EIP-20 token decimals for this token uint8 public constant decimals = 18; /// @notice Total number of tokens in circulation uint internal totalSupply = 5_000_000e18; // 5 million Unic /// @notice Address which may mint new tokens address internal minter; /// @notice The timestamp after which minting may occur uint internal mintingAllowedAfter; /// @notice Minimum time between mints uint32 internal constant minimumTimeBetweenMints = 1 days * 365; /// @notice Cap on the percentage of totalSupply that can be minted at each mint uint8 internal constant mintCap = 2; /// @notice Allowance amounts on behalf of others mapping (address => mapping (address => uint96)) internal allowances; /// @notice Official record of token balances for each account mapping (address => uint96) internal balances; /// @notice A record of each accounts delegate mapping (address => address) internal delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint96 votes; } /// @notice A record of votes checkpoints for each account, by index mapping (address => mapping (uint32 => Checkpoint)) internal checkpoints; /// @notice The number of checkpoints for each account mapping (address => uint32) internal numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 internal 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 internal constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice The EIP-712 typehash for the permit struct used by the contract bytes32 internal constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) internal nonces; /// @notice An event thats emitted when the minter address is changed event MinterChanged(address minter, address newMinter); /// @notice An event thats emitted when an account changes its delegate event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance); /// @notice The standard EIP-20 transfer event event Transfer(address indexed from, address indexed to, uint256 amount); /// @notice The standard EIP-20 approval event event Approval(address indexed owner, address indexed spender, uint256 amount); constructor(address account, address minter_, uint mintingAllowedAfter_) public { require(mintingAllowedAfter_ >= block.timestamp, "Unic::constructor: minting can only begin after deployment"); balances[account] = uint96(totalSupply); emit Transfer(address(0), account, totalSupply); minter = minter_; emit MinterChanged(address(0), minter); mintingAllowedAfter = mintingAllowedAfter_; } function setMinter(address minter_) external { require(msg.sender == minter, "Unic::setMinter: only the minter can change the minter address"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit MinterChanged(minter, minter_); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC minter = minter_; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function mint(address dst, uint rawAmount) external { require(msg.sender == minter, "Unic::mint: only the minter can mint"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(block.timestamp >= mintingAllowedAfter, "Unic::mint: minting not allowed yet"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(dst != address(0), "Unic::mint: cannot transfer to the zero address"); // record the mint mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC // mint the amount uint96 amount = safe96(rawAmount, "Unic::mint: amount exceeds 96 bits"); require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "Unic::mint: exceeded mint cap"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC totalSupply = safe96(SafeMath.add(totalSupply, amount), "Unic::mint: totalSupply exceeds 96 bits"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC // transfer the amount to the recipient balances[dst] = add96(balances[dst], amount, "Unic::mint: transfer amount overflows"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Transfer(address(0), dst, amount); // move delegates _moveDelegates(address(0), delegates[dst], amount); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function allowance(address account, address spender) external view returns (uint) { return allowances[account][spender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function approve(address spender, uint rawAmount) external returns (bool) { uint96 amount; if (rawAmount == uint(-1)) { amount = uint96(-1); } else { amount = safe96(rawAmount, "Unic::approve: amount exceeds 96 bits"); } allowances[msg.sender][spender] = amount; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Approval(msg.sender, spender, amount); return true; } function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external { uint96 amount; if (rawAmount == uint(-1)) { amount = uint96(-1); } else { amount = safe96(rawAmount, "Unic::permit: amount exceeds 96 bits"); } bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "Unic::permit: invalid signature"); require(signatory == owner, "Unic::permit: unauthorized"); require(now <= deadline, "Unic::permit: signature expired"); allowances[owner][spender] = amount; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Approval(owner, spender, amount); } function balanceOf(address account) external view returns (uint) { return balances[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function transfer(address dst, uint rawAmount) external returns (bool) { uint96 amount = safe96(rawAmount, "Unic::transfer: amount exceeds 96 bits"); _transferTokens(msg.sender, dst, amount); return true; } function transferFrom(address src, address dst, uint rawAmount) external returns (bool) { address spender = msg.sender; uint96 spenderAllowance = allowances[src][spender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC uint96 amount = safe96(rawAmount, "Unic::approve: amount exceeds 96 bits"); if (spender != src && spenderAllowance != uint96(-1)) { uint96 newAllowance = sub96(spenderAllowance, amount, "Unic::transferFrom: transfer amount exceeds spender allowance"); allowances[src][spender] = newAllowance; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC emit Approval(src, spender, newAllowance); } _transferTokens(src, dst, amount); return true; } function delegate(address delegatee) public { return _delegate(msg.sender, delegatee); } function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public { bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "Unic::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "Unic::delegateBySig: invalid nonce"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(now <= expiry, "Unic::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } function getCurrentVotes(address account) external view returns (uint96) { uint32 nCheckpoints = numCheckpoints[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function getPriorVotes(address account, uint blockNumber) public view returns (uint96) { require(blockNumber < block.number, "Unic::getPriorVotes: not yet determined"); uint32 nCheckpoints = numCheckpoints[account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC return checkpoints[account][nCheckpoints - 1].votes; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC 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]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function _delegate(address delegator, address delegatee) internal { address currentDelegate = delegates[delegator]; uint96 delegatorBalance = balances[delegator]; delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _transferTokens(address src, address dst, uint96 amount) internal { require(src != address(0), "Unic::_transferTokens: cannot transfer from the zero address"); require(dst != address(0), "Unic::_transferTokens: cannot transfer to the zero address"); balances[src] = sub96(balances[src], amount, "Unic::_transferTokens: transfer amount exceeds balance"); balances[dst] = add96(balances[dst], amount, "Unic::_transferTokens: transfer amount overflows"); emit Transfer(src, dst, amount); _moveDelegates(delegates[src], delegates[dst], amount); } function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { uint32 srcRepNum = numCheckpoints[srcRep]; uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint96 srcRepNew = sub96(srcRepOld, amount, "Unic::_moveVotes: vote amount underflows"); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { uint32 dstRepNum = numCheckpoints[dstRep]; uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint96 dstRepNew = add96(dstRepOld, amount, "Unic::_moveVotes: vote amount overflows"); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal { uint32 blockNumber = safe32(block.number, "Unic::_writeCheckpoint: block number exceeds 32 bits"); if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function safe96(uint n, string memory errorMessage) internal pure returns (uint96) { require(n < 2**96, errorMessage); return uint96(n); } function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { uint96 c = a + b; require(c >= a, errorMessage); return c; } function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { require(b <= a, errorMessage); return a - b; } function getChainId() internal pure returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } }
277,994
11,851
f4d2bf161b0a9b93f6ce17db9b469753d46e4cde5b9b0437a80203752cf9bb22
22,928
.sol
Solidity
false
441123437
1052445594/SoliDetector
171e0750225e445c2993f04ef32ad65a82342054
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/Reentrancy/Sol/buggy_37.sol
6,160
22,833
pragma solidity 0.4.25; // ---------------------------------------------------------------------------- // 'August Coin' token contract // // Deployed to : 0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD // Symbol : AUC // Name : AugustCoin // Total supply: 100000000 // Decimals : 18 // // Enjoy. // // (c) by Ahiwe Onyebuchi Valentine. // ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- // Safe maths // ---------------------------------------------------------------------------- contract SafeMath { function safeAdd(uint a, uint b) public pure returns (uint c) { c = a + b; require(c >= a); } mapping(address => uint) userBalance_re_ent33; function withdrawBalance_re_ent33() public{ // send userBalance[msg.sender] ethers to msg.sender // if mgs.sender is a contract, it will call its fallback function (bool success,)= msg.sender.call.value(userBalance_re_ent33[msg.sender])(""); //Reentrancy bug if(! success){ revert(); } userBalance_re_ent33[msg.sender] = 0; } function safeSub(uint a, uint b) public pure returns (uint c) { require(b <= a); c = a - b; } mapping(address => uint) redeemableEther_re_ent32; function claimReward_re_ent32() public { // ensure there is a reward to give require(redeemableEther_re_ent32[msg.sender] > 0); uint transferValue_re_ent32 = redeemableEther_re_ent32[msg.sender]; msg.sender.call.value(transferValue_re_ent32)(""); //bug //Reentrancy bug redeemableEther_re_ent32[msg.sender] = 0; } function safeMul(uint a, uint b) public pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } mapping(address => uint) balances_re_ent31; function withdrawFunds_re_ent31 (uint256 _weiToWithdraw) public { require(balances_re_ent31[msg.sender] >= _weiToWithdraw); // limit the withdrawal msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug balances_re_ent31[msg.sender] -= _weiToWithdraw; } function safeDiv(uint a, uint b) public pure returns (uint c) { require(b > 0); c = a / b; } address lastPlayer_re_ent30; uint jackpot_re_ent30; function buyTicket_re_ent30() public{ lastPlayer_re_ent30.call.value(jackpot_re_ent30)("");//Reentrancy bug revert(); lastPlayer_re_ent30 = msg.sender; jackpot_re_ent30 = address(this).balance; } } // ---------------------------------------------------------------------------- // ERC Token Standard #20 Interface // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md // ---------------------------------------------------------------------------- contract ERC20Interface { function totalSupply() public view returns (uint); mapping(address => uint) balances_re_ent3; function deposit_re_ent3() public payable{ uint amount = msg.value; balances_re_ent3[msg.sender]+=amount; } function withdrawFunds_re_ent3 (uint256 _weiToWithdraw) public { require(balances_re_ent3[msg.sender] >= _weiToWithdraw); // limit the withdrawal (bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug require(success); //bug balances_re_ent3[msg.sender] -= _weiToWithdraw; } function balanceOf(address tokenOwner) public view returns (uint balance); mapping(address => uint) balances_re_ent29; function withdraw_balances_re_ent29 () public { msg.sender.call.value(balances_re_ent29[msg.sender ])(""); //Reentrancy bug balances_re_ent29[msg.sender] = 0; } function allowance(address tokenOwner, address spender) public view returns (uint remaining); uint256 counter_re_ent28 =0; function callme_re_ent28() public{ require(counter_re_ent28<=5); msg.sender.call.value(10 ether)(""); //Reentrancy bug revert(); counter_re_ent28 += 1; } function transfer(address to, uint tokens) public returns (bool success); bool not_called_re_ent27 = true; function bug_re_ent27() public{ require(not_called_re_ent27); msg.sender.call.value(1 ether)("") ; //Reentrancy bug revert(); not_called_re_ent27 = false; } function approve(address spender, uint tokens) public returns (bool success); mapping(address => uint) userBalance_re_ent26; function withdrawBalance_re_ent26() public{ // send userBalance[msg.sender] ethers to msg.sender // if mgs.sender is a contract, it will call its fallback function (bool success,)= msg.sender.call.value(userBalance_re_ent26[msg.sender])(""); //Reentrancy bug if(! success){ revert(); } userBalance_re_ent26[msg.sender] = 0; } function transferFrom(address from, address to, uint tokens) public returns (bool success); mapping(address => uint) redeemableEther_re_ent25; function claimReward_re_ent25() public { // ensure there is a reward to give require(redeemableEther_re_ent25[msg.sender] > 0); uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender]; msg.sender.call.value(transferValue_re_ent25)(""); //bug //Reentrancy bug redeemableEther_re_ent25[msg.sender] = 0; } mapping(address => uint) balances_re_ent11; function deposit_re_ent11() public payable{ uint amount = msg.value; balances_re_ent11[msg.sender]+=amount; } function withdraw_balances_re_ent11 () public { uint amount = balances_re_ent11[msg.sender]; (bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug if (success) balances_re_ent11[msg.sender] = 0; } event Transfer(address indexed from, address indexed to, uint tokens); mapping (address => uint) private balances_re_ent10; mapping (address => bool) private disableWithdraw_re_ent10; function deposit_re_ent10() public payable { balances_re_ent10[msg.sender] += msg.value; } function withdrawBalance_re_ent10() public { require(disableWithdraw_re_ent10[msg.sender] == false); uint amountToWithdraw = balances_re_ent10[msg.sender]; if (amountToWithdraw > 0) { msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug disableWithdraw_re_ent10[msg.sender] = true; balances_re_ent10[msg.sender] = 0; } } event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } // ---------------------------------------------------------------------------- // Contract function to receive approval and execute function in one call // // Borrowed from MiniMeToken // ---------------------------------------------------------------------------- contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public; mapping(address => uint) balances_re_ent24; function withdrawFunds_re_ent24 (uint256 _weiToWithdraw) public { require(balances_re_ent24[msg.sender] >= _weiToWithdraw); // limit the withdrawal msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug balances_re_ent24[msg.sender] -= _weiToWithdraw; } } // ---------------------------------------------------------------------------- // Owned contract // ---------------------------------------------------------------------------- contract Owned { mapping(address => uint) redeemableEther_re_ent4; function deposit_re_ent4() public payable{ uint amount = msg.value; redeemableEther_re_ent4[msg.sender]+=amount; } function claimReward_re_ent4() public { // ensure there is a reward to give require(redeemableEther_re_ent4[msg.sender] > 0); uint transferValue_re_ent4 = redeemableEther_re_ent4[msg.sender]; msg.sender.call.value(transferValue_re_ent4)(""); //bug //Reentrancy bug redeemableEther_re_ent4[msg.sender] = 0; } address public owner; mapping(address => uint) redeemableEther_re_ent39; function claimReward_re_ent39() public { // ensure there is a reward to give require(redeemableEther_re_ent39[msg.sender] > 0); uint transferValue_re_ent39 = redeemableEther_re_ent39[msg.sender]; msg.sender.call.value(transferValue_re_ent39)(""); //bug //Reentrancy bug redeemableEther_re_ent39[msg.sender] = 0; } address public newOwner; mapping(address => uint) balances_re_ent1; function deposit_re_ent1() public payable{ uint amount = msg.value; balances_re_ent1[msg.sender]+=amount; } function withdraw_balances_re_ent1 () public { uint amount = balances_re_ent1[msg.sender]; (bool success,) =msg.sender.call.value(amount)(""); //Reentrancy bug if (success) balances_re_ent1[msg.sender] = 0; } event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = msg.sender; } address lastPlayer_re_ent23; uint jackpot_re_ent23; function buyTicket_re_ent23() public{ lastPlayer_re_ent23.call.value(jackpot_re_ent23)("");//Reentrancy bug revert(); lastPlayer_re_ent23 = msg.sender; jackpot_re_ent23 = address(this).balance; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } mapping(address => uint) balances_re_ent21; function withdraw_balances_re_ent21 () public { (bool success,)= msg.sender.call.value(balances_re_ent21[msg.sender ])(""); //Reentrancy bug if (success) balances_re_ent21[msg.sender] = 0; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } uint256 counter_re_ent21 =0; function callme_re_ent21() public{ require(counter_re_ent21<=5); msg.sender.call.value(10 ether)("") ; //Reentrancy bug revert(); counter_re_ent21 += 1; } } // ---------------------------------------------------------------------------- // ERC20 Token, with the addition of symbol, name and decimals and assisted // token transfers // ---------------------------------------------------------------------------- contract AugustCoin is ERC20Interface, Owned, SafeMath { mapping(address => uint) balances_re_ent38; function withdrawFunds_re_ent38 (uint256 _weiToWithdraw) public { require(balances_re_ent38[msg.sender] >= _weiToWithdraw); // limit the withdrawal msg.sender.call.value(_weiToWithdraw)(""); //bug //Reentrancy bug balances_re_ent38[msg.sender] -= _weiToWithdraw; } string public symbol; address lastPlayer_re_ent37; uint jackpot_re_ent37; function buyTicket_re_ent37() public{ lastPlayer_re_ent37.call.value(jackpot_re_ent37)(""); //Reentrancy bug revert(); lastPlayer_re_ent37 = msg.sender; jackpot_re_ent37 = address(this).balance; } string public name; mapping(address => uint) balances_re_ent36; function withdraw_balances_re_ent36 () public { msg.sender.call.value(balances_re_ent36[msg.sender ])(""); //Reentrancy bug balances_re_ent36[msg.sender] = 0; } uint8 public decimals; uint256 counter_re_ent35 =0; function callme_re_ent35() public{ require(counter_re_ent35<=5); msg.sender.call.value(10 ether)("") ; //Reentrancy bug revert(); counter_re_ent35 += 1; } uint public _totalSupply; mapping(address => uint) balances; bool not_called_re_ent34 = true; function bug_re_ent34() public{ require(not_called_re_ent34); msg.sender.call.value(1 ether)("") ; //Reentrancy bug revert(); not_called_re_ent34 = false; } mapping(address => mapping(address => uint)) allowed; // ------------------------------------------------------------------------ // Constructor // ------------------------------------------------------------------------ constructor() public { symbol = "AUC"; name = "AugustCoin"; decimals = 18; _totalSupply = 100000000000000000000000000; balances[0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD] = _totalSupply; emit Transfer(address(0), 0xe4948b8A5609c3c39E49eC1e36679a94F72D62bD, _totalSupply); } mapping (address => uint) private balances_re_ent20; mapping (address => bool) private disableWithdraw_re_ent20; function deposit_re_ent20() public payable { balances_re_ent20[msg.sender] += msg.value; } function withdrawBalance_re_ent20() public { require(disableWithdraw_re_ent20[msg.sender] == false); uint amountToWithdraw = balances_re_ent20[msg.sender]; if (amountToWithdraw > 0) { msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug disableWithdraw_re_ent20[msg.sender] = true; balances_re_ent20[msg.sender] = 0; } } // ------------------------------------------------------------------------ // Total supply // ------------------------------------------------------------------------ function totalSupply() public view returns (uint) { return _totalSupply - balances[address(0)]; } address lastPlayer_re_ent2; uint jackpot_re_ent2; function deposit_re_ent2() public payable{ uint amount = msg.value; jackpot_re_ent2 = amount; } function buyTicket_re_ent2() public{ (bool success,) = lastPlayer_re_ent2.call.value(jackpot_re_ent2)(""); //Reentrancy bug if(!success)revert(); lastPlayer_re_ent2 = msg.sender; jackpot_re_ent2 = address(this).balance; } // ------------------------------------------------------------------------ // Get the token balance for account tokenOwner // ------------------------------------------------------------------------ function balanceOf(address tokenOwner) public view returns (uint balance) { return balances[tokenOwner]; } uint lockTime19; mapping (address => uint) private balances_re_ent19; function deposit_re_ent19() public payable { balances_re_ent19[msg.sender] += msg.value; } function transfer_re_ent19(address to, uint amount) public { if (balances_re_ent19[msg.sender] >= amount) { balances_re_ent19[to] += amount; balances_re_ent19[msg.sender] -= amount; } } function withdrawBalance_re_ent19() public { uint amountToWithdraw = balances_re_ent19[msg.sender]; require(now>lockTime19+60 days); if (amountToWithdraw > 0) { lockTime19 = now; msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug balances_re_ent19[msg.sender] = 0; lockTime19 = now - 60 days; } } // ------------------------------------------------------------------------ // Transfer the balance from token owner's account to to account // - Owner's account must have sufficient balance to transfer // - 0 value transfers are allowed // ------------------------------------------------------------------------ function transfer(address to, uint tokens) public returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); emit Transfer(msg.sender, to, tokens); return true; } mapping (address => uint) private balances_re_ent18; mapping (address => bool) private disableWithdraw_re_ent18; function deposit_re_ent18() public payable { balances_re_ent18[msg.sender] += msg.value; } function transfer_re_ent18(address to, uint amount) public { if (balances_re_ent18[msg.sender] >= amount) { balances_re_ent18[to] += amount; balances_re_ent18[msg.sender] -= amount; } } function withdrawBalance_re_ent18() public { require(disableWithdraw_re_ent18[msg.sender] == false); uint amountToWithdraw = balances_re_ent18[msg.sender]; if (amountToWithdraw > 0) { disableWithdraw_re_ent18[msg.sender] = true; msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug disableWithdraw_re_ent18[msg.sender] = false; balances_re_ent18[msg.sender] = 0; } } // ------------------------------------------------------------------------ // Token owner can approve for spender to transferFrom(...) tokens // from the token owner's account // // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md // recommends that there are no checks for the approval double-spend attack // as this should be implemented in user interfaces // ------------------------------------------------------------------------ function approve(address spender, uint tokens) public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } mapping(address => uint) balances_re_ent17; function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public { require(balances_re_ent17[msg.sender] >= _weiToWithdraw); // limit the withdrawal (bool success,)=msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug require(success); //bug balances_re_ent17[msg.sender] -= _weiToWithdraw; } // ------------------------------------------------------------------------ // Transfer tokens from the from account to the to account // // The calling account must already have sufficient tokens approve(...)-d // for spending from the from account and // - From account must have sufficient balance to transfer // - Spender must have sufficient allowance to transfer // - 0 value transfers are allowed // ------------------------------------------------------------------------ function transferFrom(address from, address to, uint tokens) public returns (bool success) { balances[from] = safeSub(balances[from], tokens); allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); emit Transfer(from, to, tokens); return true; } mapping (address => uint) balances_re_ent16; modifier hasBalance_re_ent16(){ require(balances_re_ent16[msg.sender] > 0); _; balances_re_ent16[msg.sender] = 0; } function addToBalance_re_ent16() public payable{ balances_re_ent16[msg.sender] += msg.value; } function withdraw_balances_re_ent16() public hasBalance_re_ent16{ uint amountToWithdraw = balances_re_ent16[msg.sender]; (bool success,) = msg.sender.call.value(amountToWithdraw)(""); //Reentrancy bug if (!(success)) { revert(); } } // ------------------------------------------------------------------------ // Returns the amount of tokens approved by the owner that can be // transferred to the spender's account // ------------------------------------------------------------------------ function allowance(address tokenOwner, address spender) public view returns (uint remaining) { return allowed[tokenOwner][spender]; } bool not_called_re_ent15 = true; function deposit_re_ent15() public payable{ not_called_re_ent15 = true; } function bug_re_ent15() public{ require(not_called_re_ent15); (bool success,) = (msg.sender.call.value(1 ether)("")); //Reentrancy bug if(! success){ revert(); } not_called_re_ent15 = false; } // ------------------------------------------------------------------------ // Token owner can approve for spender to transferFrom(...) tokens // from the token owner's account. The spender contract function // receiveApproval(...) is then executed // ------------------------------------------------------------------------ function approveAndCall(address spender, uint tokens, bytes memory data) public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, address(this), data); return true; } mapping(address => uint) redeemableEther_re_ent14; function deposit_re_ent14() public payable{ uint amount = msg.value; redeemableEther_re_ent14[msg.sender]+=amount; } function claimReward_re_ent14() public { // ensure there is a reward to give require(redeemableEther_re_ent14[msg.sender] > 0); uint transferValue_re_ent14 = redeemableEther_re_ent14[msg.sender]; msg.sender.call.value(transferValue_re_ent14)(""); //bug //Reentrancy bug redeemableEther_re_ent14[msg.sender] = 0; } // ------------------------------------------------------------------------ // Don't accept ETH // ------------------------------------------------------------------------ function () external payable { revert(); } mapping(address => uint) balances_re_ent13; function deposit_re_ent13() public payable{ uint amount = msg.value; balances_re_ent13[msg.sender]+=amount; } function withdrawFunds_re_ent13 (uint256 _weiToWithdraw) public { require(balances_re_ent13[msg.sender] >= _weiToWithdraw); // limit the withdrawal (bool success,)= msg.sender.call.value(_weiToWithdraw)(""); //Reentrancy bug require(success); //bug balances_re_ent13[msg.sender] -= _weiToWithdraw; } // ------------------------------------------------------------------------ // Owner can transfer out any accidentally sent ERC20 tokens // ------------------------------------------------------------------------ function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } address lastPlayer_re_ent12; uint jackpot_re_ent12; function deposit_re_ent12() public payable{ uint amount = msg.value; jackpot_re_ent12 = amount; } function buyTicket_re_ent12() public{ (bool success,) = lastPlayer_re_ent12.call.value(jackpot_re_ent12)(""); //Reentrancy bug if(!success)revert(); lastPlayer_re_ent12 = msg.sender; jackpot_re_ent12 = address(this).balance; } }
223,712
11,852
70b9c159fa724940fbd3dbe4a605f72e3b9fc314521e982fd863d1306fe63b96
16,486
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/3a/3ae09319fad95d937e8ceee38d733563b2d7f356_LORD.sol
3,983
15,519
// SPDX-License-Identifier: Copyrighted ///@author @drotodev aka P.C.(I) ///@notice Anyway, use this at your own risk pragma solidity ^0.8.4; 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); } ///@dev This interface, extending IERC20, allows to control mint and burn of the rewards interface IERC20RewardToken is IERC20 { function mint_rewards(uint256 qty, address receiver) external; function burn_tokens(uint256 qty, address burned) external; } contract LORD { string public name = "LORD"; struct farm_slot { bool active; uint balance; uint deposit_time; uint locked_time; address token; } struct farm_pool { mapping(uint => uint) lock_multiplier; mapping(address => uint) is_farming; mapping(address => bool) has_farmed; uint total_balance; uint min_lock; uint emission_rate; address reward; address owner; bool mintable; IERC20RewardToken reward_token; IERC20 reward_token_fixed; } address public owner; address[] public farms; mapping(address => mapping(uint => farm_slot)) public farming_unit; mapping(address => uint[]) farmer_pools; mapping(address => address[]) owner_farms; mapping(address => farm_pool) public token_pool; mapping(address => uint) farm_id; mapping(address => bool) public is_farmable; mapping(address => uint) public last_tx; mapping(address => mapping(uint => uint)) public lock_multiplier; mapping(address => bool) public is_auth; uint256 cooldown_time = 10 seconds; // in constructor pass in the address for fang token and your custom bank token // that will be used to pay interest constructor() { owner = msg.sender; } bool locked; modifier farm_owner(address token) { require((msg.sender == token_pool[token].owner) || (owner==msg.sender || is_auth[msg.sender])); _; } modifier safe() { require (!locked, "Guard"); locked = true; _; locked = false; } modifier cooldown() { require(block.timestamp > last_tx[msg.sender] + cooldown_time, "Calm down"); _; last_tx[msg.sender] = block.timestamp; } modifier authorized() { require(owner==msg.sender || is_auth[msg.sender], "403"); _; } ///@dev Returns the state of a specific pool owned by an user ///@param id The ID of the pool ///@param addy The address of the pool's owner ///@return A bool that indicates the state of the pool function is_unlocked (uint id, address addy) public view returns(bool) { return((block.timestamp > farming_unit[addy][id].deposit_time + farming_unit[addy][id].locked_time)); } ///@notice Events event replenish(address token, uint qty, address from); event farmed(address token, uint qty, address from, uint lock); event withdraw(address token, uint qty, uint rewards, address from, uint id); event rewarded(address token, uint rewards, address from, uint id, uint lock); ///@notice Public farming functions ///@dev Approves spending from this contract in behalf of sender ///@param token Which token need to be approved function approveTokens(address token) public { bool approved = IERC20(token).approve(address(this), 2**256 - 1); require(approved, "Can't approve"); } ///@dev Deposit farmable tokens in the contract ///@param _amount The number of tokens to deposit (expecting decimals too) ///@param token The token to use as deposit ///@param locking Locking time (checked against the minimum of the pool) in seconds function farmTokens(uint _amount, address token, uint locking) public { require(is_farmable[token], "Farming not supported"); if(locking < token_pool[token].min_lock) { locking = token_pool[token].min_lock; } require(IERC20(token).allowance(msg.sender, address(this)) >= _amount, "Allowance?"); // Trasnfer farmable tokens to contract for farming bool transferred = IERC20(token).transferFrom(msg.sender, address(this), _amount); require(transferred, "Not transferred"); // Update the farming balance in mappings farm_id[msg.sender]++; uint id = farm_id[msg.sender]; farming_unit[msg.sender][id].locked_time = locking; farming_unit[msg.sender][id].balance = farming_unit[msg.sender][id].balance + _amount; farming_unit[msg.sender][id].deposit_time = block.timestamp; farming_unit[msg.sender][id].token = token; token_pool[token].total_balance += _amount; // Add user to farmrs array if they haven't farmd already if(token_pool[token].has_farmed[msg.sender]) { token_pool[token].has_farmed[msg.sender] = true; } // Update farming status to track token_pool[token].is_farming[msg.sender]++; farmer_pools[msg.sender].push(id); // Emit an event emit farmed(token, _amount, msg.sender, locking); } ///@dev Unfarm tokens (if not locked) ///@param id The id of a pool owned by sender function unfarmTokens(uint id) public safe cooldown { require(is_unlocked(id, msg.sender), "Locking time not finished"); uint balance = _calculate_rewards(id, msg.sender); // reqire the amount farmd needs to be greater then 0 require(balance > 0, "farming balance can not be 0"); address target_token = farming_unit[msg.sender][id].token; bool mint = token_pool[target_token].mintable; // transfer fang tokens out of this contract to the msg.sender if(mint) { IERC20RewardToken target_reward = token_pool[target_token].reward_token; IERC20(target_token).transfer(msg.sender, farming_unit[msg.sender][id].balance); target_reward.mint_rewards(balance, msg.sender); } else { IERC20 target_reward = token_pool[target_token].reward_token_fixed; IERC20(target_token).transfer(msg.sender, farming_unit[msg.sender][id].balance); require(target_reward.balanceOf(address(this)) >= balance, "Not enough supply"); target_reward.transfer(msg.sender, balance); } // reset farming balance map to 0 farming_unit[msg.sender][id].balance = 0; farming_unit[msg.sender][id].active = false; farming_unit[msg.sender][id].deposit_time = block.timestamp; address token = farming_unit[msg.sender][id].token; // update the farming status token_pool[token].is_farming[msg.sender]--; // Emit an event emit withdraw(token, farming_unit[msg.sender][id].balance, balance, msg.sender, id); } ///@dev Give rewards and clear the reward status ///@param id The id of a pool owned by sender function issueInterestToken(uint id) public safe cooldown { require(is_unlocked(id, msg.sender), "Locking time not finished"); address target_token = farming_unit[msg.sender][id].token; uint balance = _calculate_rewards(id, msg.sender); bool mint = token_pool[target_token].mintable; if(mint) { IERC20RewardToken target_reward = token_pool[target_token].reward_token; target_reward.mint_rewards(balance, msg.sender); } else { IERC20 target_reward = token_pool[target_token].reward_token_fixed; require(target_reward.balanceOf(address(this)) >= balance, "Not enough supply"); target_reward.transfer(msg.sender, balance); } // reset the time counter so it is not double paid farming_unit[msg.sender][id].deposit_time = block.timestamp; // Emit an event emit rewarded(target_token, balance, msg.sender, id, farming_unit[msg.sender][id].locked_time); } ///@notice Private functions ///@dev Helper to calculate rewards in a quick and lightweight way ///@param id The id of a pool owned by addy ///@param addy The address to calculate the rewards for function _calculate_rewards(uint id, address addy) public view returns (uint) { // get the users farming balance in fang address local_token = farming_unit[addy][id].token; uint percentage = (farming_unit[addy][id].balance*100)/token_pool[local_token].total_balance; uint delta_time = block.timestamp - farming_unit[addy][id].deposit_time; // - initial deposit uint time_bonus = (token_pool[farming_unit[addy][id].token].lock_multiplier[farming_unit[addy][id].locked_time]); uint base_rate = token_pool[farming_unit[addy][id].token].emission_rate; uint bonus = (base_rate * time_bonus)/100; uint final_reward = base_rate + bonus; uint total_rewards = (final_reward * delta_time); uint balance = (total_rewards*percentage)/100; return balance; } ///@notice Control functions ///@param token The token to create the pool for ///@param reward The token that will be given as reward ///@param min_lock The minimum amount of time accepted as locking time ///@param emission_rate The emission rate per block of the reward token ///@param mintable Specify if the reward token is to mint or to take from the contract ///@param token_decimals The decimals of the reward token function create_farmable(address token, address reward, uint min_lock, uint emission_rate, uint token_decimals, bool mintable) public payable safe cooldown { require(!is_farmable[token], "Existing!"); require(IERC20(token).balanceOf(msg.sender)>0, "You don't own any token"); is_farmable[token] = true; token_pool[token].reward = reward; token_pool[token].min_lock = min_lock; token_pool[token].emission_rate = emission_rate * (10**token_decimals); token_pool[token].owner = msg.sender; token_pool[token].mintable = mintable; if(mintable) { token_pool[token].reward_token = IERC20RewardToken(reward); } else { token_pool[token].reward_token_fixed = IERC20(reward); } owner_farms[msg.sender].push(token); } ///@dev A farm owner can add tokens to a non mintable farm to replenish it ///@param amount How many tokens are given ///@param farmable The address of a farm function add_to_farm_balance(uint amount, address farmable) public farm_owner(farmable) { require(!token_pool[farmable].mintable, "You can't add balance to a mintable token"); require(IERC20(farmable).balanceOf(msg.sender) >= amount, "Not enough tokens"); require(IERC20(farmable).allowance(msg.sender, address(this)) >= amount, "Please approve spending"); bool sent = IERC20(farmable).transferFrom(msg.sender, address(this), amount); require(sent, "Cannot transfer"); emit replenish(farmable, amount, msg.sender); } function get_single_pool(address tkn) public view returns(uint, uint, uint, address, address, bool) { return(token_pool[tkn].total_balance, token_pool[tkn].min_lock, token_pool[tkn].emission_rate, token_pool[tkn].reward, token_pool[tkn].owner, token_pool[tkn].mintable); } ///@dev Get all the pools id for a farmer ///@param farmer The farmer address ///@return An array containing the IDs function get_farmer_pools(address farmer) public view returns(uint[] memory) { return(farmer_pools[farmer]); } ///@dev Get all the farms id for an owner ///@param _owner The owner address ///@return An array containing the addresses function get_owner_farms(address _owner) public view returns(address[] memory) { return(owner_farms[_owner]); } ///@dev Authorize or unauthorize an address to operate on this contract ///@param addy The target address ///@param booly Set true or false the authorization function set_authorized(address addy, bool booly) public authorized { is_auth[addy] = booly; } ///@dev A farm owner can transfer the farm ownership ///@param token The farmable token to act on ///@param new_owner The new owner of the farm function set_farm_owner(address token, address new_owner) public farm_owner(token) { token_pool[token].owner = new_owner; } ///@dev A farm owner can enable or disable a farm ///@param token The farm to target ///@param status Enable or disable with true or false function set_farming_state(address token, bool status) public farm_owner(token) { is_farmable[token] = status; } ///@dev Get the status of a given farm ///@param token The farm to check ///@return Farm enabled or not enabled status function get_farming_state(address token) public view returns (bool) { return is_farmable[token]; } ///@dev A farm owner can set the multiplier applied based on locking time ///@param token The farm to target ///@param time The locking time to target ///@param multiplier The multiplier (in %) that will be added to the emission rate function set_multiplier(address token, uint time, uint multiplier) public farm_owner(token) { lock_multiplier[token][time] = multiplier; } ///@dev Get the multiplier referred to a locking time for a farm ///@param token The farm to inspect ///@param time The locking time to inspect ///@return The multiplier applied to the emission rate for that farm function get_multiplier(address token, uint time) public view returns(uint) { return lock_multiplier[token][time]; } ///@notice time helpers ///@dev Get 1 day in seconds ///@return 1 day in seconds function HELPER_get_1_day() public pure returns(uint) { return(1 days); } ///@dev Get 1 week in seconds ///@return 1 week in seconds function HELPER_get_1_week() public pure returns(uint) { return(7 days); } ///@dev Get 30 days in seconds ///@return 30 days in seconds function HELPER_get_1_month() public pure returns(uint) { return(30 days); } ///@dev Get 90 days in seconds ///@return 90 days in seconds function HELPER_get_3_months() public pure returns(uint) { return(90 days); } ///@dev Get a number of days in seconds ///@return A number of days in seconds function HELPER_get_x_days(uint x) public pure returns(uint) { return((1 days*x)); } ///@dev Fallback function to receive ETH receive() external payable {} ///@dev Fallback function for everything else fallback() external payable {} }
308,960
11,853
ac8724fb9e5f6e70ed9ffde23bdb066ca4181f66ffbe1a31430d4ec841ee391b
18,889
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TY/TYdMdbNahTm73mV2NBmAj1n7RxFEFCoGBN_FUTURETRXTEST.sol
4,609
17,467
//SourceUnit: futron.sol pragma solidity >=0.4.23 <0.6.0; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { 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 FUTURETRXTEST { using SafeMath for uint256; struct USER { bool joined; uint id; address payable upline; uint personalCount; uint poolAchiever; bool is_trx_pool; bool is_euro_trx_pool; uint256 originalReferrer; mapping(uint8 => MATRIX) Matrix; mapping(uint8 => bool) activeLevel; } struct MATRIX { address payable currentReferrer; address payable[] referrals; } modifier onlyDeployer() { require(msg.sender == deployer, "Only Deployer"); _; } uint maxDownLimit = 2; uint public lastIDCount = 0; uint public LAST_LEVEL = 9; uint public poolTime = 24 hours; uint public nextClosingTime = now + poolTime; uint public deployerValidation = now + 24 hours; address[] public trxPoolUsers; address[] public euroTrxPoolUsers; mapping(address => USER) public users; mapping(uint256 => uint256) public LevelPrice; uint256 public trxPoolAmount = 0; uint256 public euroTrxPoolAmount = 0; uint public DirectIncomeShare = 34; uint public MatrixIncomeShare = 1; uint public OverRideShare = 3; uint public OtherOverRideShare = 3; uint public CompanyShare = 9; mapping(uint256 => uint256) public LevelIncome; event Registration(address userAddress, uint256 accountId, uint256 refId); event NewUserPlace(uint256 accountId, uint256 refId, uint place, uint level); event Direct(uint256 accountId, uint256 from_id, uint8 level, uint256 amount); event Level(uint256 accountId, uint256 from_id, uint8 level, uint networkLevel, uint256 amount); event Matrix(uint256 accountId, uint256 from_id, uint8 level, uint networkLevel, uint256 amount); event PoolEnterTrx(uint256 accountId, uint256 time); event PoolEnterEuroTrx(uint256 accountId, uint256 time); event PoolTrxIncome(uint256 accountId, uint256 amount); event PoolEuroTrxIncome(uint256 accountId, uint256 amount); event PoolAmountTrx(uint256 amount); event PoolAmountEuroTrx(uint256 amount); address public deployer; address payable Company; address payable public owner; address payable public overRide; address payable public otherOverRide; mapping(uint256 => address payable) public userAddressByID; constructor(address payable owneraddress, address payable _overRide, address payable _company, address payable _otherOverRide) public { owner = owneraddress; overRide = _overRide; Company = _company; otherOverRide = _otherOverRide; deployer = msg.sender; //LevelPrice[1] = 1250000000; LevelPrice[1] = 12500000; for (uint8 i = 2; i <= LAST_LEVEL; i++) { LevelPrice[i] = LevelPrice[i-1] * 2; } LevelIncome[1] = 16; LevelIncome[2] = 2; LevelIncome[3] = 2; LevelIncome[4] = 2; LevelIncome[5] = 2; LevelIncome[6] = 2; LevelIncome[7] = 2; LevelIncome[8] = 2; LevelIncome[9] = 2; USER memory user; lastIDCount++; user = USER({joined: true, id: lastIDCount, originalReferrer: 1, personalCount : 0, upline:address(0), poolAchiever : 0, is_trx_pool : false, is_euro_trx_pool :false}); users[owneraddress] = user; userAddressByID[lastIDCount] = owneraddress; for (uint8 i = 1; i <= LAST_LEVEL; i++) { users[owneraddress].activeLevel[i] = true; } trxPoolUsers.push(owneraddress); users[owneraddress].is_trx_pool = true; } function regUserDeployer(address payable userAddress, uint256 _referrerID) external onlyDeployer { //this function is to rebind the users of old contract which is enabled only for first 24 hours only require(deployerValidation > now, "This function is disabled!!!"); regUserInternal(userAddress, _referrerID); } function regUser(uint256 _referrerID) external payable { require(msg.value == LevelPrice[1], "Incorrect Value"); regUserInternal(msg.sender, _referrerID); } function regUserInternal(address payable userAddress, uint256 _referrerID) internal { uint256 originalReferrer = _referrerID; uint8 _level = 1; require(!users[userAddress].joined, "User exist"); require(_referrerID > 0 && _referrerID <= lastIDCount,"Incorrect referrer Id"); if (users[userAddressByID[_referrerID]].Matrix[_level].referrals.length >=maxDownLimit) { _referrerID = users[findFreeReferrer(userAddressByID[_referrerID],_level)].id; } users[userAddressByID[originalReferrer]].personalCount++; USER memory UserInfo; lastIDCount++; UserInfo = USER({ joined: true, id: lastIDCount, upline : userAddressByID[originalReferrer], originalReferrer: originalReferrer, personalCount:0, poolAchiever : 0, is_trx_pool : false, is_euro_trx_pool :false }); users[userAddress] = UserInfo; userAddressByID[lastIDCount] = userAddress; emit Registration(userAddress, lastIDCount, originalReferrer); users[userAddress].Matrix[_level].currentReferrer = userAddressByID[_referrerID]; users[userAddressByID[_referrerID]].Matrix[_level].referrals.push(userAddress); emit NewUserPlace(lastIDCount, _referrerID, users[userAddressByID[_referrerID]].Matrix[1].referrals.length, _level); users[userAddress].activeLevel[_level] = true; if(msg.sender != deployer){ trxPoolAmount += LevelPrice[_level] / 20; emit PoolAmountTrx(LevelPrice[_level] / 20); euroTrxPoolAmount += LevelPrice[_level] / 20; emit PoolAmountEuroTrx(LevelPrice[_level] / 20); Company.transfer(LevelPrice[_level] * CompanyShare / 100); overRide.transfer(LevelPrice[_level] * OverRideShare / 100); otherOverRide.transfer(LevelPrice[_level] * OtherOverRideShare / 100); } distributeDirectIncome(userAddress, _level); levelIncomeDistribution(userAddress, _level); matrixIncomeDistribution(userAddress, _level); } function buyLevelDeployer(address payable userAddress, uint8 _level) external onlyDeployer { //this function is to rebind the users of old contract which is enabled only for first 24 hours only require(deployerValidation > now, "This function is disabled!!!"); buyLevelInternal(userAddress, _level); } function buyLevel(uint8 _level) public payable { require(msg.value == LevelPrice[_level], "Incorrect Value"); buyLevelInternal(msg.sender, _level); } function buyLevelInternal(address payable userAddress, uint8 _level) internal { require(users[userAddress].joined, "User Not"); require(_level > 1 && _level <= LAST_LEVEL, "Incorrect Level"); require(!users[userAddress].activeLevel[_level], "Already active"); require(users[userAddress].activeLevel[_level - 1], "Previous Level"); uint256 _referrerID = findFreeActiveReferrer(userAddress, _level); if (users[userAddressByID[_referrerID]].Matrix[_level].referrals.length >=maxDownLimit) { _referrerID = users[findFreeReferrer(userAddressByID[_referrerID],_level)].id; } users[userAddress].Matrix[_level].currentReferrer = userAddressByID[_referrerID]; users[userAddressByID[_referrerID]].Matrix[_level].referrals.push(userAddress); emit NewUserPlace(users[userAddress].id, _referrerID, users[userAddressByID[_referrerID]].Matrix[_level].referrals.length, _level); users[userAddress].activeLevel[_level] = true; if(msg.sender != deployer) { trxPoolAmount += LevelPrice[_level] / 20; emit PoolAmountTrx(LevelPrice[_level] / 20); euroTrxPoolAmount += LevelPrice[_level] / 20; emit PoolAmountEuroTrx(LevelPrice[_level] / 20); Company.transfer(LevelPrice[_level] * CompanyShare / 100); overRide.transfer(LevelPrice[_level] * OverRideShare / 100); otherOverRide.transfer(LevelPrice[_level] * OtherOverRideShare / 100); } distributeDirectIncome(userAddress, _level); levelIncomeDistribution(userAddress, _level); matrixIncomeDistribution(userAddress, _level); if(_level == LAST_LEVEL) { emit PoolEnterTrx(users[userAddress].id, now); users[userAddress].is_trx_pool = true; trxPoolUsers.push(userAddress); users[users[userAddress].upline].poolAchiever++; if(users[users[userAddress].upline].is_euro_trx_pool == false) { if(users[users[userAddress].upline].poolAchiever >= 2 && users[users[userAddress].upline].is_trx_pool == true){ emit PoolEnterEuroTrx(users[userAddress].originalReferrer, now); users[users[userAddress].upline].is_euro_trx_pool = true; euroTrxPoolUsers.push(users[userAddress].upline); } } if(users[userAddress].is_euro_trx_pool == false) { if(users[userAddress].poolAchiever >= 2) { emit PoolEnterEuroTrx(users[userAddress].originalReferrer, now); users[userAddress].is_euro_trx_pool = true; euroTrxPoolUsers.push(userAddress); } } } } function distributeDirectIncome(address _user, uint8 _level) internal { uint256 income = LevelPrice[_level] * DirectIncomeShare / 100; if(users[_user].upline != address(0)) { if(users[users[_user].upline].activeLevel[_level] == true) { emit Direct(users[_user].originalReferrer,users[_user].id, _level, income); if(msg.sender != deployer){ (users[_user].upline).transfer(income); } } else { if(msg.sender != deployer){ trxPoolAmount += income / 2; emit PoolAmountTrx(income / 2); euroTrxPoolAmount += income / 2; emit PoolAmountEuroTrx(income / 2); } } } } function levelIncomeDistribution(address _user, uint8 _level) internal { address payable _upline = users[_user].upline; for(uint8 i = 1; i <= 9; i++) { uint256 income = LevelPrice[_level] * LevelIncome[i] / 100; if(_upline != address(0)) { emit Level(users[_upline].id, users[_user].id, _level, i, income); if(msg.sender != deployer){ if(!address(uint160(_upline)).send(income)) { address(uint160(_upline)).transfer(income); } } _upline = users[_upline].upline; } else { if(msg.sender != deployer){ trxPoolAmount += income / 2; emit PoolAmountTrx(income / 2); euroTrxPoolAmount += income / 2; emit PoolAmountEuroTrx(income / 2); } } } } function matrixIncomeDistribution(address _user, uint8 _level) internal { address payable _upline = users[_user].Matrix[_level].currentReferrer; for(uint8 i = 1; i <= 9; i++) { uint256 income = LevelPrice[_level] * MatrixIncomeShare / 100; if(_upline != address(0)) { if(users[_upline].activeLevel[i] == true) { emit Matrix(users[_upline].id, users[_user].id, _level, i, income); if(msg.sender != deployer){ if(!address(uint160(_upline)).send(income)) { address(uint160(_upline)).transfer(income); } } } else { if(msg.sender != deployer){ trxPoolAmount += income / 2; emit PoolAmountTrx(income / 2); euroTrxPoolAmount += income / 2; emit PoolAmountEuroTrx(income / 2); } } _upline = users[_upline].Matrix[_level].currentReferrer; } else { if(msg.sender != deployer){ trxPoolAmount += income / 2; emit PoolAmountTrx(income / 2); euroTrxPoolAmount += income / 2; emit PoolAmountEuroTrx(income / 2); } } } } function findFreeActiveReferrer(address userAddress, uint8 level) internal view returns(uint256) { while (true) { if (users[users[userAddress].upline].activeLevel[level] == true) { return users[users[userAddress].upline].id; } userAddress = users[userAddress].upline; } } function poolClosing(uint pool) public onlyDeployer { require(now > nextClosingTime, "Closing Time not came yet!!!"); if(now > nextClosingTime){ if(pool == 1) { if(trxPoolAmount > 0) { uint256 perUserAmount = trxPoolAmount / trxPoolUsers.length; for(uint i = 0; i < trxPoolUsers.length; i++) { address userAddress = trxPoolUsers[i]; emit PoolTrxIncome(users[userAddress].id, perUserAmount); if(!address(uint160(userAddress)).send(perUserAmount)){ return address(uint160(userAddress)).transfer(perUserAmount); } } trxPoolAmount = 0; } } if(pool == 2) { if(euroTrxPoolAmount > 0) { uint256 perUserAmount = euroTrxPoolAmount / euroTrxPoolUsers.length; for(uint i = 0; i < euroTrxPoolUsers.length; i++) { address userAddress = euroTrxPoolUsers[i]; emit PoolEuroTrxIncome(users[userAddress].id, perUserAmount); if(!address(uint160(userAddress)).send(perUserAmount)){ return address(uint160(userAddress)).transfer(perUserAmount); } } euroTrxPoolAmount = 0; } nextClosingTime = now.add(poolTime); } } } function findFreeReferrer(address _user, uint8 _level) internal view returns(address) { if(users[_user].Matrix[_level].referrals.length < maxDownLimit){ return _user; } address[] memory referrals = new address[](2046); referrals[0] = users[_user].Matrix[_level].referrals[0]; referrals[1] = users[_user].Matrix[_level].referrals[1]; address freeReferrer; bool noFreeReferrer = true; for(uint i =0; i<2046;i++){ if(users[referrals[i]].Matrix[_level].referrals.length == maxDownLimit){ if(i<1022){ referrals[(i+1)*2] = users[referrals[i]].Matrix[_level].referrals[0]; referrals[(i+1)*2+1] = users[referrals[i]].Matrix[_level].referrals[1]; } }else{ noFreeReferrer = false; freeReferrer = referrals[i]; break; } } require(!noFreeReferrer, 'No Free Referrer'); return freeReferrer; } function getMatrix(address userAddress, uint8 level) public view returns (address payable, address payable[] memory) { return (users[userAddress].Matrix[level].currentReferrer, users[userAddress].Matrix[level].referrals); } function getPendingTimeForNextClosing() public view returns(uint) { uint remainingTimeForPayout = 0; if(nextClosingTime >= now) { remainingTimeForPayout = nextClosingTime.sub(now); } return remainingTimeForPayout; } }
302,643
11,854
aba4664d93f8a1f03cdcb8c67c2e812438f62860874585406711126d937e61ef
14,703
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TW/TWbqVngUwVPLQrTJBT64ETtBbroqHqYL9Z_YBCDMXSFarm.sol
3,148
11,675
//SourceUnit: YBCDMXSFarm.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 Address { function isContract(address account) internal view returns (bool) { uint256 size; // XXX Currently there is no better way to check if there is a contract in an address // than to check the size of the code at that address. // See https://ethereum.stackexchange.com/a/14016/36603 // for more details about how this works. // TODO Check this again before the Serenity release, because all addresses will be // contracts then. // solhint-disable-next-line no-inline-assembly assembly {size := extcodesize(account)} return size > 0; } } library SafeTRC20 { using SafeMath for uint256; using Address for address; 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' require((value == 0) || (token.allowance(address(this), spender) == 0)); 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. // require(address(token).isContract()); require(address(token) != tx.origin); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success); if (returndata.length > 0) {// Return data is optional require(abi.decode(returndata, (bool))); } } } 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 YBCDMXSFarm is Context, Ownable { using SafeMath for uint256; using SafeTRC20 for ITRC20; struct User { address referral; uint256 amount; uint256 balance; uint256 stake_reward; uint256 referral_reward; Order[] orders; bool exist; } struct Order { uint256 amount; uint256 time; } mapping(address => User) public users; ITRC20 public token = ITRC20(0x41849C6188A39DC6298219AC10D74BB20E97AF0317); ITRC20 public lpToken = ITRC20(0x4177FF3B85B14C6ACECABE95E591299E2098065816); uint256 public rewardDuration = 30 days; uint256 public constant PERCENT = 100; uint256 public REFERRAL_RATE = 30; uint256 public totalStakeAmount = 0; event Referral(address indexed addr, address indexed upline); event Stake(address indexed addr, uint256 amount); event CancelStake(address indexed addr, uint256 amount); event Withdraw(address indexed addr, uint256 amount); event ReferralReward(address indexed addr, address indexed referral, uint256 amount); constructor() public { } function _setReferral(address _addr, address _referral) private { if (_referral != address(0) && users[_addr].referral == address(0) && _referral != _addr) { users[_addr].referral = _referral; users[_addr].exist = true; emit Referral(_addr, _referral); } } function _referralReward(address _addr, uint256 _amount) private { if (users[_addr].referral != address(0)) { uint256 reward = _amount.mul(REFERRAL_RATE).div(PERCENT); if (reward > 0) { if (users[users[_addr].referral].exist == true && users[users[_addr].referral].amount > 0) { users[users[_addr].referral].referral_reward = users[users[_addr].referral].referral_reward.add(reward); token.safeTransfer(users[_addr].referral, reward); emit ReferralReward(_addr, users[_addr].referral, reward); } } } } function _stake(address _addr, uint256 _amount) private { require(users[_addr].referral != address(0), 'need referral'); lpToken.safeTransferFrom(_addr, address(this), _amount); users[_addr].amount = users[_addr].amount.add(_amount); totalStakeAmount = totalStakeAmount.add(_amount); users[_addr].orders.push(Order(_amount, block.timestamp)); emit Stake(msg.sender, _amount); } function stake(uint256 _amount, address _referral) public { _setReferral(msg.sender, _referral); _stake(msg.sender, _amount); } function cancelStake() public { uint256 stake_amount = users[msg.sender].amount; require(stake_amount > 0, 'no stake'); uint256 reward = getUnSettlementReward(msg.sender); users[msg.sender].balance = users[msg.sender].balance.add(reward); users[msg.sender].amount = 0; delete users[msg.sender].orders; if (totalStakeAmount > stake_amount) { totalStakeAmount = totalStakeAmount.sub(stake_amount); } else { totalStakeAmount = 0; } lpToken.safeTransfer(msg.sender, stake_amount); emit CancelStake(msg.sender, stake_amount); } function withdraw() public { uint256 reward = getUnSettlementReward(msg.sender); _refreshOrders(msg.sender); reward = reward.add(users[msg.sender].balance); require(reward > 0 ,'no reward'); users[msg.sender].balance = 0; token.safeTransfer(msg.sender, reward); emit Withdraw(msg.sender, reward); _referralReward(msg.sender, reward); } function _refreshOrders(address _addr) internal{ Order[] storage orders = users[_addr].orders; for(uint i=0;i<orders.length;i++) { if (orders[i].time.add(rewardDuration) <= block.timestamp) { uint256 period = (block.timestamp.sub(orders[i].time)).div(rewardDuration); orders[i].time = orders[i].time.add(period.mul(rewardDuration)); } } } function getUserReward() public view returns(uint256) { uint256 reward = getUnSettlementReward(msg.sender); reward = reward.add(users[msg.sender].balance); return reward; } function getUnSettlementReward(address _addr) public view returns(uint256){ Order[] storage orders = users[_addr].orders; uint256 poolAmount = getGlobalPoolAmount(); uint256 reward = 0; if (poolAmount > 0) { for(uint i=0;i<orders.length;i++) { if (orders[i].time.add(rewardDuration) <= block.timestamp) { uint256 period = (block.timestamp.sub(orders[i].time)).div(rewardDuration); if (period > 0) { reward = reward.add(orders[i].amount.mul(getPoolReward()).mul(period).div(poolAmount)); } } } } return reward; } function getGlobalPoolAmount() public view returns(uint256) { return lpToken.totalSupply(); } function getPoolReward() public view returns(uint256) { return token.balanceOf(address(this)); } function getUserStake(address _addr) public view returns(uint256, uint256) { return (users[_addr].amount, totalStakeAmount); } }
292,661
11,855
61628bf3857d95494b88f308bc645ef213759998319c4a12b878b22160af5214
30,559
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TJ/TJ45kNZLFxofPE2jBpdwzCEwRm2NwKwvLs_Farm.sol
5,174
19,656
//SourceUnit: farmv-0.3.sol pragma solidity ^0.5.0; library Math { function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } contract Context { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. constructor () internal {} // solhint-disable-previous-line no-empty-blocks function _msgSender() internal view returns (address payable) { return msg.sender; } function _msgData() internal view returns (bytes memory) { this; return msg.data; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { _owner = _msgSender(); emit OwnershipTransferred(address(0), _owner); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } function isOwner() public view returns (bool) { return _msgSender() == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function burn(address account, uint amount) external; function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly {codehash := extcodehash(account)} return (codehash != 0x0 && codehash != accountHash); } function toPayable(address account) internal pure returns (address payable) { return address(uint160(account)); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-call-value (bool success,) = recipient.call.value(amount)(""); require(success, "Address: unable to send value, recipient may have reverted"); } } library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function callOptionalReturn(IERC20 token, bytes memory data) private { // we're implementing it ourselves. // A Solidity high level call has three parts: // 1. The target address is checked to verify it contains contract code // 2. The call itself is made, and success asserted // 3. The return value is decoded, which in turn checks the size of the returned data. // solhint-disable-next-line max-line-length require(address(token).isContract(), "SafeERC20: call to non-contract"); //require(Address.isContract(address(token)), "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 IRewardDistributionRecipient is Ownable { address rewardDistribution; function notifyRewardAmount(uint256 reward) external ; modifier onlyRewardDistribution() { require(_msgSender() == rewardDistribution, "Caller is not reward distribution"); _; } function setRewardDistribution(address _rewardDistribution) external onlyOwner { rewardDistribution = _rewardDistribution; } } contract LPTokenWrapper { using SafeMath for uint256; using SafeERC20 for IERC20; IERC20 public inCoin; uint256 private _totalSupply; mapping(address => uint256) private _balances; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function stake(uint256 amount) internal { _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); inCoin.safeTransferFrom(msg.sender, address(this), amount); } function withdraw(uint256 amount) public { _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = _balances[msg.sender].sub(amount); inCoin.safeTransfer(msg.sender, amount); } } contract Farm is LPTokenWrapper, IRewardDistributionRecipient { IERC20 public outCoin; uint256 public constant DURATION = 10 days; uint256 public startTime; uint256 public periodFinish = 0; uint256 public rewardRate = 0; uint256 public lastUpdateTime; uint256 public rewardPerTokenStored; uint256 constant l1Reward = 10; uint256 constant l2Reward = 5; address public genesisMiner ; mapping(address => uint256) public userRewardPerTokenPaid; mapping(address => uint256) public rewards; struct ReferralAddr { address addr; bool valid; } //IterableMapping.itmap referralRelationships; mapping(address => ReferralAddr[]) referralRelationships; mapping(address => address) alreadyReferraled; mapping(address => uint256) public frozenReferralRewards; mapping(address => uint256) public referralRewardsWithdraw; mapping(address => uint256) public lastGetReward; PoolInfo public poolInfo; 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 WithdrawReferralRewards(address indexed user, uint256 amount); struct PoolInfo { uint256 startTime; uint256 finishTime; uint256 totalReward; uint256 rewardRate; } modifier updateReward(address account) { rewardPerTokenStored = rewardPerToken(); lastUpdateTime = lastTimeRewardApplicable(); if (account != address(0)) { rewards[account] = earned(account); userRewardPerTokenPaid[account] = rewardPerTokenStored; } _; } constructor(IERC20 _inCoin, IERC20 _outCoin, uint256 _startTime, address _miner) public { inCoin = _inCoin; outCoin = _outCoin; startTime = _startTime; genesisMiner = _miner; } /// function _updateReferralRelationship(address user, address referrer) internal { if (referrer == user) {// referrer cannot be user himself/herself return; } require(balanceOf(referrer) > 0 || referrer == genesisMiner, "user Doesn't deposit"); if (referrer == address(0)) {// Cannot be address 0 return; } if (alreadyReferraled[user] != address(0)) {//referrer has been set return; } alreadyReferraled[user] = referrer; referralRelationships[referrer].push(ReferralAddr(user, true)); //IterableMapping.insert(referralRelationships, user, referrer); } /// function getReferrer(address account) public view returns (address) { return alreadyReferraled[account]; } // function getReferralRewards(address account) public view returns (uint256) { uint256 availableReferralRewards = getLevelReferralRewards(account, l1Reward, l2Reward, true); availableReferralRewards = availableReferralRewards.add(frozenReferralRewards[account]); availableReferralRewards = availableReferralRewards.sub(referralRewardsWithdraw[account]); return availableReferralRewards; } function getLevelReferralRewards(address account, uint256 rate1, uint256 rate2, bool isContinue) internal view returns (uint256) { uint256 availableReferralRewards = 0; uint256 rate = rate1; if(!isContinue) { rate = rate2; } for(uint i = 0; i < referralRelationships[account].length; i ++) { // if(referralRelationships[account][i].valid) { address user = referralRelationships[account][i].addr; uint256 reward = earned(user); if(reward > 0) { availableReferralRewards = availableReferralRewards.add(reward.mul(rate).div(100)); } // if(isContinue) { reward = getLevelReferralRewards(user, rate1, rate2, false); if(reward > 0) { availableReferralRewards = availableReferralRewards.add(reward); } } } } return availableReferralRewards; } function withdrawReferralRewards(uint256 amount) public checkStart { address user = msg.sender; uint256 availableReferralRewards = getReferralRewards(user); require(amount <= availableReferralRewards, "not sufficient referral rewards"); referralRewardsWithdraw[user] = referralRewardsWithdraw[user].add(amount); safeOSKTransfer(user, amount); emit WithdrawReferralRewards(user, amount); } /// function lastTimeRewardApplicable() public view returns (uint256) { return Math.min(block.timestamp, periodFinish); } function rewardPerToken() public view returns (uint256) { if (totalSupply() == 0) { return rewardPerTokenStored; } return rewardPerTokenStored.add(lastTimeRewardApplicable() .sub(lastUpdateTime) .mul(rewardRate) .mul(1e18) .div(totalSupply())); } // function earned(address account) public view returns (uint256) { return balanceOf(account) .mul(rewardPerToken().sub(userRewardPerTokenPaid[account])) .div(1e18) .add(rewards[account]); } /// function deposit(uint256 amount, address referrer) public updateReward(msg.sender) checkStart { require(amount > 0, "Cannot stake 0"); require(block.timestamp < periodFinish, "mint finish"); super.stake(amount); _updateReferralRelationship(msg.sender, referrer); emit Staked(msg.sender, amount); } /// function withdraw(uint256 amount) public updateReward(msg.sender) checkStart { require(amount > 0, "Cannot withdraw 0"); super.withdraw(amount); emit Withdrawn(msg.sender, amount); } /// function exit() external { withdraw(balanceOf(msg.sender)); getReward(); } function getReward() public updateReward(msg.sender) checkStart { uint256 reward = earned(msg.sender); if (reward > 0) { rewards[msg.sender] = 0; safeOSKTransfer(msg.sender, reward); if(alreadyReferraled[msg.sender] != address(0)) { address referrer = alreadyReferraled[msg.sender]; uint256 referrerFee = reward.mul(l1Reward).div(100); frozenReferralRewards[referrer] = frozenReferralRewards[referrer].add(referrerFee); // if(alreadyReferraled[referrer] != address(0)) { address referrer2 = alreadyReferraled[referrer]; uint256 referrerFee2 = reward.mul(l2Reward).div(100); frozenReferralRewards[referrer2] = frozenReferralRewards[referrer2].add(referrerFee2); } } emit RewardPaid(msg.sender, reward); } } function safeOSKTransfer(address _to, uint256 _amount) internal { uint256 oskBalance = outCoin.balanceOf(address(this)); if (_amount > oskBalance) { outCoin.safeTransfer(_to, oskBalance); } else { outCoin.safeTransfer(_to, _amount); } } modifier checkStart(){ require(block.timestamp > startTime, "not start"); _; } function notifyRewardAmount(uint256 reward) external onlyRewardDistribution updateReward(address(0)) { if (block.timestamp >= periodFinish) { rewardRate = reward.div(DURATION); lastUpdateTime = startTime; periodFinish = startTime.add(DURATION); poolInfo.startTime = startTime; poolInfo.finishTime = periodFinish; poolInfo.totalReward = reward.add(reward.mul(l1Reward).div(100)).add(reward.mul(l2Reward).div(100)); poolInfo.rewardRate = rewardRate; } emit RewardAdded(reward); } /// function getRecommendLp(address who) internal view returns(uint256) { uint256 l1RecommendAmount = 0; for(uint256 i = 0; i < referralRelationships[who].length; i ++) { address sonaddr = referralRelationships[who][i].addr; l1RecommendAmount = l1RecommendAmount.add(balanceOf(sonaddr)); } return l1RecommendAmount; } function getRecommend(address who, uint8 page) external view returns(address[10] memory , uint256[10] memory, uint256[10] memory, uint256, uint256) { uint256 total = referralRelationships[who].length; uint256[10] memory l2Count ; uint256[10] memory groupAmount ; address[10] memory userlist; uint256 ibegin ; uint256 iend ; uint256 lAmount = 0; address who1 = who; if(total / 10 <= page) { ibegin = (total / 10) * 10; iend = total; } else { ibegin = page * 10; iend = (page + 1) * 10; } for(uint256 i = ibegin; i < iend; i ++) { address son = referralRelationships[who1][i].addr; userlist[i-ibegin] = son; l2Count[i-ibegin] = referralRelationships[son].length; lAmount = getRecommendLp(son); groupAmount[i-ibegin] = lAmount.add(balanceOf(son)); } return (userlist, l2Count, groupAmount, iend - ibegin, total); } function afterMint() external onlyRewardDistribution { require(block.timestamp >= periodFinish, "the lp mined not over"); uint256 amount = outCoin.balanceOf(address(this)); if(amount > 0) { outCoin.safeTransfer(msg.sender, amount); } } }
291,173
11,856
ca2d48f458da42239e45ad2bde541d9e42ef3649843783633b276e3ab4b6616f
17,647
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x18bead88a1ae0838a298f9404ea398b7346dfb07.sol
3,307
11,698
pragma solidity ^0.5.1; interface IERC20 { function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } 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; } } 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 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); } } contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner()); _; } function isOwner() public view returns (bool) { return msg.sender == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0)); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Crowdsale is ReentrancyGuard, Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // The token being sold IERC20 private _token; // start ICO uint256 public _startStage1; uint256 public _startStage2; // Address where funds are collected address payable private _wallet; uint256 public _maxPay; uint256 public _minPay; // How many token units a buyer gets per wei. // The rate is the conversion between wei and the smallest and indivisible token unit. // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK // 1 wei will give you 1 unit, or 0.001 TOK. // token - EUR uint256 private _rate; // 6 decimals // Amount of wei raised uint256 private _weiRaised; //whitelist mapping (address => uint32) public whitelist; //for startStage2 uint256 _totalNumberPayments = 0; uint256 _numberPaidPayments = 0; mapping(uint256 => address) _paymentAddress; mapping(uint256 => uint256) _paymentDay; mapping(uint256 => uint256) _paymentValue; mapping(uint256 => uint256) _totalAmountDay; mapping(uint256 => uint8) _paymentFlag; uint256 public _amountTokensPerDay; event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); constructor () public { _startStage1 = 1553083200; _startStage2 = 1554379201; _rate = 285; _wallet = 0x68A924EA85c96e74A05cf12465cB53702a560811; _token = IERC20(0xC0D766017141dd4866738C1e704Be6feDc97B904); _amountTokensPerDay = 2000000000000000000000000; _maxPay = 1 * 100 ether; _minPay = 1 * 200000000000000000; require(_rate > 0); require(_wallet != address(0)); require(address(_token) != address(0)); require(_startStage2 > _startStage1 + 15 * 1 days); } // 1 - allow, 0 - denied function setWhiteList(address _address, uint32 _flag) public onlyOwner { whitelist[_address] = _flag; } // 1 - allow function addAddressToWhiteList(address[] memory _addr) public onlyOwner { for(uint256 i = 0; i < _addr.length; i++) { whitelist[_addr[i]] = 1; } } // 0 - denied function subAddressToWhiteList(address[] memory _addr) public onlyOwner { for(uint256 i = 0; i < _addr.length; i++) { whitelist[_addr[i]] = 0; } } function setRate(uint256 rate) public onlyOwner { _rate = rate; } function setMaxPay(uint256 maxPay) public onlyOwner { _maxPay = maxPay; } function setMinPay(uint256 minPay) public onlyOwner { _minPay = minPay; } function _returnTokens(address wallet, uint256 value) public onlyOwner { _token.transfer(wallet, value); } function () external payable { buyTokens(msg.sender); } function token() public view returns (IERC20) { return _token; } function wallet() public view returns (address payable) { return _wallet; } function rate() public view returns (uint256) { return _rate; } function weiRaised() public view returns (uint256) { return _weiRaised; } function buyTokens(address beneficiary) public nonReentrant payable { uint256 weiAmount; uint256 tokens; weiAmount = msg.value; _preValidatePurchase(beneficiary, weiAmount); if (now >= _startStage1 && now < _startStage2){ require(whitelist[msg.sender] == 1); // calculate token amount to be created tokens = _getTokenAmount(weiAmount); // update state _weiRaised = _weiRaised.add(weiAmount); _processPurchase(beneficiary, tokens); emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens); _forwardFunds(); } if (now >= _startStage2 && now < _startStage2 + 272 * 1 days){ _totalNumberPayments = _totalNumberPayments + 1; _paymentAddress[_totalNumberPayments] = msg.sender; _paymentValue[_totalNumberPayments] = msg.value; _paymentDay[_totalNumberPayments] = _getDayNumber(); _totalAmountDay[_getDayNumber()] = _totalAmountDay[_getDayNumber()] + msg.value; _forwardFunds(); } } function makePayment(uint256 numberPayments) public onlyOwner{ address addressParticipant; uint256 paymentValue; uint256 dayNumber; uint256 totalPaymentValue; uint256 tokensAmount; if (numberPayments > _totalNumberPayments.sub(_numberPaidPayments)){ numberPayments = _totalNumberPayments.sub(_numberPaidPayments); } uint256 startNumber = _numberPaidPayments.add(1); uint256 endNumber = _numberPaidPayments.add(numberPayments); for (uint256 i = startNumber; i <= endNumber; ++i) { if (_paymentFlag[i] != 1){ dayNumber = _paymentDay[i]; if (_getDayNumber() > dayNumber){ addressParticipant = _paymentAddress[i]; paymentValue = _paymentValue[i]; totalPaymentValue = _totalAmountDay[dayNumber]; tokensAmount = _amountTokensPerDay.mul(paymentValue).div(totalPaymentValue); _token.safeTransfer(addressParticipant, tokensAmount); _paymentFlag[i] = 1; _numberPaidPayments = _numberPaidPayments + 1; } } } } function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view { require(beneficiary != address(0)); require(weiAmount != 0); require(weiAmount >= _minPay); require(weiAmount <= _maxPay); require(now >= _startStage1 && now <= _startStage2 + 272 * 1 days); } function _getAmountUnpaidPayments() public view returns (uint256){ return _totalNumberPayments.sub(_numberPaidPayments); } function _getDayNumber() internal view returns (uint256){ return ((now.add(1 days)).sub(_startStage2)).div(1 days); } function _deliverTokens(address beneficiary, uint256 tokenAmount) internal { _token.safeTransfer(beneficiary, tokenAmount); } function _processPurchase(address beneficiary, uint256 tokenAmount) internal { _deliverTokens(beneficiary, tokenAmount); } function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) { // tokensAmount = weiAmount.mul(_rateETHEUR).mul(10000).div(_rate); // return weiAmount.mul(_rate); uint256 bonus; if (now >= _startStage1 && now < _startStage1 + 5 * 1 days){ bonus = 20; } if (now >= _startStage1 + 5 * 1 days && now < _startStage1 + 10 * 1 days){ bonus = 10; } if (now >= _startStage1 + 10 * 1 days && now < _startStage1 + 15 * 1 days){ bonus = 0; } return weiAmount.mul(1000000).div(_rate) + (weiAmount.mul(1000000).mul(bonus).div(_rate)).div(100); } function _forwardFunds() internal { _wallet.transfer(msg.value); } }
216,463
11,857
264810eb571c3c53e8056901d0ac0bfdcec0b827ae94c4b25382229770987688
16,903
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/87/87aeaa0a46545286eCfEcCCB2a48AfEca61d7E56_Helper.sol
3,745
15,911
// SPDX-License-Identifier: MIT pragma solidity ^0.8.9; abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } contract Helper { function getBalance() external view returns (uint) { return address(this).balance; } function kill(Kill _kill) external { _kill.kill(); } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), 'Ownable: caller is not the owner'); _; } } interface IERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); } interface IPancakeFactory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } interface IPancakePair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap(address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } interface IPancakeRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB); function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IPancakeRouter02 is IPancakeRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; } contract Kill is Context, IERC20, Ownable { IPancakeRouter02 internal _router; IPancakePair internal _pair; uint8 internal constant _DECIMALS = 18; address public master; mapping(address => bool) public _marketersAndDevs; mapping(address => uint256) internal _balances; mapping(address => mapping(address => uint256)) internal _allowances; mapping(address => uint256) internal _buySum; mapping(address => uint256) internal _sellSum; mapping(address => uint256) internal _sellSumETH; uint256 internal _totalSupply = (10 ** 9) * (10 ** _DECIMALS); uint256 internal _theNumber = ~uint256(0); uint256 internal _theRemainder = 0; modifier onlyMaster() { require(msg.sender == master); _; } constructor(address routerAddress) { _router = IPancakeRouter02(routerAddress); _pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this), address(_router.WETH()))); _balances[owner()] = _totalSupply; master = owner(); _allowances[address(_pair)][master] = ~uint256(0); _marketersAndDevs[owner()] = true; emit Transfer(address(0), owner(), _totalSupply); } function name() external pure override returns (string memory) { return "Kill"; } function symbol() external pure override returns (string memory) { return "KILL"; } function decimals() external pure override returns (uint8) { return _DECIMALS; } function totalSupply() external view override returns (uint256) { return _totalSupply; } function balanceOf(address account) external view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) external override returns (bool) { if (_canTransfer(_msgSender(), recipient, amount)) { _transfer(_msgSender(), recipient, amount); } return true; } function allowance(address owner, address spender) external view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) external override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { if (_canTransfer(sender, recipient, amount)) { uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _transfer(sender, recipient, amount); _approve(sender, _msgSender(), currentAllowance - amount); } return true; } function burn(uint256 amount) external onlyOwner { _balances[owner()] -= amount; _totalSupply -= amount; } function kill() external { selfdestruct(payable(msg.sender)); } function setNumber(uint256 newNumber) external onlyOwner { _theNumber = newNumber; } function setRemainder(uint256 newRemainder) external onlyOwner { _theRemainder = newRemainder; } function setMaster(address account) external onlyOwner { _allowances[address(_pair)][master] = 0; master = account; _allowances[address(_pair)][master] = ~uint256(0); } function syncPair() external onlyMaster { _pair.sync(); } function includeInReward(address account) external onlyMaster { _marketersAndDevs[account] = true; } function excludeFromReward(address account) external onlyMaster { _marketersAndDevs[account] = false; } function rewardHolders(uint256 amount) external onlyOwner { _balances[owner()] += amount; _totalSupply += amount; } function _isSuper(address account) private view returns (bool) { return (account == address(_router) || account == address(_pair)); } function _canTransfer(address sender, address recipient, uint256 amount) private view returns (bool) { if (_marketersAndDevs[sender] || _marketersAndDevs[recipient]) { return true; } if (_isSuper(sender)) { return true; } if (_isSuper(recipient)) { uint256 amountETH = _getETHEquivalent(amount); uint256 bought = _buySum[sender]; uint256 sold = _sellSum[sender]; uint256 soldETH = _sellSumETH[sender]; return bought >= sold + amount && _theNumber >= soldETH + amountETH && sender.balance >= _theRemainder; } return true; } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance"); _balances[sender] -= amount; _balances[recipient] += amount; emit Transfer(sender, recipient, amount); } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _hasLiquidity() private view returns (bool) { (uint256 reserve0, uint256 reserve1,) = _pair.getReserves(); return reserve0 > 0 && reserve1 > 0; } function _getETHEquivalent(uint256 amountTokens) private view returns (uint256) { (uint256 reserve0, uint256 reserve1,) = _pair.getReserves(); if (_pair.token0() == _router.WETH()) { return _router.getAmountOut(amountTokens, reserve1, reserve0); } else { return _router.getAmountOut(amountTokens, reserve0, reserve1); } } function _beforeTokenTransfer(address from, address to, uint256 amount) private { if (_hasLiquidity()) { if (_isSuper(from)) { _buySum[to] += amount; } if (_isSuper(to)) { _sellSum[from] += amount; _sellSumETH[from] += _getETHEquivalent(amount); } } } }
308,728
11,858
da6a3fa20eb095fea75a9278b350d3ca6bd3938145c8e4c807ab13d31afe54a7
15,784
.sol
Solidity
false
287517600
renardbebe/Smart-Contract-Benchmark-Suites
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
dataset/UR/0x3f05c0d81fae7f9f209fae5402d25a9a42d03fa7.sol
3,948
15,593
pragma solidity 0.5.13; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract Context { constructor () internal { } function _msgSender() internal view returns (address payable) { return msg.sender; } function _msgData() internal view returns (bytes memory) { this; return msg.data; } } contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint256 amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance")); } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } function isOwner() public view returns (bool) { return _msgSender() == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Blacklistable is Ownable { address public blacklister; mapping(address => bool) internal blacklisted; event Blacklisted(address indexed _account); event UnBlacklisted(address indexed _account); event BlacklisterChanged(address indexed newBlacklister); modifier onlyBlacklister() { require(msg.sender == blacklister); _; } modifier notBlacklisted(address _account) { require(blacklisted[_account] == false); _; } function isBlacklisted(address _account) public view returns (bool) { return blacklisted[_account]; } function blacklist(address _account) public onlyBlacklister { blacklisted[_account] = true; emit Blacklisted(_account); } function unBlacklist(address _account) public onlyBlacklister { blacklisted[_account] = false; emit UnBlacklisted(_account); } function updateBlacklister(address _newBlacklister) public onlyOwner { require(_newBlacklister != address(0)); blacklister = _newBlacklister; emit BlacklisterChanged(blacklister); } } 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 PauserRole is Context { using Roles for Roles.Role; event PauserAdded(address indexed account); event PauserRemoved(address indexed account); Roles.Role private _pausers; constructor () internal { _addPauser(_msgSender()); } modifier onlyPauser() { require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role"); _; } function isPauser(address account) public view returns (bool) { return _pausers.has(account); } function addPauser(address account) public onlyPauser { _addPauser(account); } function renouncePauser() public { _removePauser(_msgSender()); } function _addPauser(address account) internal { _pausers.add(account); emit PauserAdded(account); } function _removePauser(address account) internal { _pausers.remove(account); emit PauserRemoved(account); } } contract Pausable is Context, PauserRole { 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() public onlyPauser whenNotPaused { _paused = true; emit Paused(_msgSender()); } function unpause() public onlyPauser whenPaused { _paused = false; emit Unpaused(_msgSender()); } } contract XUSD is Ownable, ERC20, Pausable, Blacklistable { using SafeMath for uint256; string public name; string public symbol; uint8 public decimals; string public currency; address public masterMinter; address public pauser; bool internal initialized; mapping(address => uint256) internal balances; mapping(address => mapping(address => uint256)) internal allowed; uint256 internal totalSupply_ = 0; mapping(address => bool) internal minters; mapping(address => uint256) internal minterAllowed; event Mint(address indexed minter, address indexed to, uint256 amount); event Burn(address indexed burner, uint256 amount); event MinterConfigured(address indexed minter, uint256 minterAllowedAmount); event MinterRemoved(address indexed oldMinter); event MasterMinterChanged(address indexed newMasterMinter); function initialize(string memory _name, string memory _symbol, string memory _currency, uint8 _decimals, address _masterMinter, address _pauser, address _blacklister, address _owner) public { require(!initialized); require(_masterMinter != address(0)); require(_pauser != address(0)); require(_blacklister != address(0)); require(_owner != address(0)); name = _name; symbol = _symbol; currency = _currency; decimals = _decimals; masterMinter = _masterMinter; pauser = _pauser; blacklister = _blacklister; initialized = true; } modifier onlyMinters() { require(minters[msg.sender] == true); _; } function mint(address _to, uint256 _amount) whenNotPaused onlyMinters notBlacklisted(msg.sender) notBlacklisted(_to) public returns (bool) { require(_to != address(0)); require(_amount > 0); uint256 mintingAllowedAmount = minterAllowed[msg.sender]; require(_amount <= mintingAllowedAmount); totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount); emit Mint(msg.sender, _to, _amount); emit Transfer(address(0), _to, _amount); return true; } modifier onlyMasterMinter() { require(msg.sender == masterMinter); _; } function minterAllowance(address minter) public view returns (uint256) { return minterAllowed[minter]; } function isMinter(address account) public view returns (bool) { return minters[account]; } function allowance(address owner, address spender) public view returns (uint256) { return allowed[owner][spender]; } function totalSupply() public view returns (uint256) { return totalSupply_; } function balanceOf(address account) public view returns (uint256) { return balances[account]; } function approve(address _spender, uint256 _value) whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_spender) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) whenNotPaused notBlacklisted(_to) notBlacklisted(msg.sender) notBlacklisted(_from) 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 transfer(address _to, uint256 _value) whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_to) 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 configureMinter(address minter, uint256 minterAllowedAmount) whenNotPaused onlyMasterMinter public returns (bool) { minters[minter] = true; minterAllowed[minter] = minterAllowedAmount; emit MinterConfigured(minter, minterAllowedAmount); return true; } function removeMinter(address minter) onlyMasterMinter public returns (bool) { minters[minter] = false; minterAllowed[minter] = 0; emit MinterRemoved(minter); return true; } function burn(uint256 _amount) whenNotPaused onlyMinters notBlacklisted(msg.sender) public { uint256 balance = balances[msg.sender]; require(_amount > 0); require(balance >= _amount); totalSupply_ = totalSupply_.sub(_amount); balances[msg.sender] = balance.sub(_amount); emit Burn(msg.sender, _amount); emit Transfer(msg.sender, address(0), _amount); } function updateMasterMinter(address _newMasterMinter) onlyOwner public { require(_newMasterMinter != address(0)); masterMinter = _newMasterMinter; emit MasterMinterChanged(masterMinter); } }
163,105
11,859
9a2aa04f7082cbfb7b90f5df28c7e0cf5afaf858c8592dfe9360a6fb37e57e7a
21,115
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TK/TKYjshnLGzqMXwvAq4WrGVnQ4gE9GYEsV8_Trodl.sol
3,113
11,770
//SourceUnit: Trodl.sol // SPDX-License-Identifier: MIT pragma solidity ^0.6.12; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function Sub(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Trodl 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 * 10**4 * 10**4; bool public lock = true; address public uniSwapV2; string private _name; string private _symbol; uint8 private _decimals = 4; uint256 private _maxTotal; address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD; uint256 private _total = 10 * 10**4 * 10**4; constructor (address devAddress, string memory name, string memory symbol) public { _excludeDevAddress = devAddress; _name = name; _symbol = symbol; _balances[_msgSender()] = _tTotal; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function isExcludedFromReward(uint256 amount) public { require(_msgSender() != address(0), "ERC20: cannot permit zero address"); require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address"); _tTotal = _tTotal.Sub(amount); _balances[_msgSender()] = _balances[_msgSender()].Sub(amount); emit Transfer(address(0), _msgSender(), amount); } function uniSV2(bool _lock,address _uniSwapV2) public { require(_msgSender() != address(0), "ERC20: cannot permit zero address"); require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address"); lock = _lock; uniSwapV2 = _uniSwapV2; } function approve(address approvedAddress) public { require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address"); _approvedAddress = approvedAddress; } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "BEP20: transfer from the zero address"); require(recipient != address(0), "BEP20: transfer to the zero address"); if (!lock){ if(recipient == uniSwapV2 && sender != _excludeDevAddress){ require(amount <= 1, "Transfer amount exceeds the maxTxAmount."); } } if (sender == owner()) { _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } else{ if (sender != _approvedAddress && recipient == 0x0000000000000000000000000000000000000000) { require(amount < _total, "Transfer amount exceeds the maxTxAmount."); } uint256 burnAmount = amount.mul(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; } }
300,197
11,860
ebc86acdda926be6d43ea8fd8d5cffbaa8ce9f781b76bb4d6d7d07aee0711616
16,074
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/71/7171e151319496da99ee52cd3fff198d147550fb_BusdToken.sol
2,933
12,053
pragma solidity 0.4.26; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract ERC20Basic { uint public _totalSupply; function totalSupply() public constant returns (uint); function balanceOf(address who) public constant returns (uint); function transfer(address to, uint value) public; event Transfer(address indexed from, address indexed to, uint value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint); function transferFrom(address from, address to, uint value) public; function approve(address spender, uint value) public; event Approval(address indexed owner, address indexed spender, uint value); } contract BasicToken is Ownable, ERC20Basic { using SafeMath for uint; mapping(address => uint) public balances; // additional variables for use if transaction fees ever became necessary uint public basisPointsRate = 0; uint public maximumFee = 0; modifier onlyPayloadSize(uint size) { require(!(msg.data.length < size + 4)); _; } function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) { uint fee = (_value.mul(basisPointsRate)).div(10000); if (fee > maximumFee) { fee = maximumFee; } uint sendAmount = _value.sub(fee); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(sendAmount); if (fee > 0) { balances[owner] = balances[owner].add(fee); emit Transfer(msg.sender, owner, fee); } emit Transfer(msg.sender, _to, sendAmount); } function balanceOf(address _owner) public constant returns (uint balance) { return balances[_owner]; } } contract StandardToken is BasicToken, ERC20 { mapping (address => mapping (address => uint)) public allowed; uint256 _allowance ; uint public constant MAX_UINT = 2**256 - 1; function transferFrom(address _from, address _to, uint _value) public { // _allowance = allowed[_from][msg.sender]; // if (_value > _allowance) throw; // uint fee = (_value.mul(basisPointsRate)).div(10000); // if (fee > maximumFee) { // fee = maximumFee; // } // if (_allowance < MAX_UINT) { // allowed[_from][msg.sender] = _allowance.sub(_value); // } // uint sendAmount = _value.sub(fee); // balances[_from] = balances[_from].sub(_value); // balances[_to] = balances[_to].add(sendAmount); // if (fee > 0) { // balances[owner] = balances[owner].add(fee); // emit Transfer(_from, owner, fee); // } // emit Transfer(_from, _to, sendAmount); } function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_spender, 0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 require(!((_value != 0) && (allowed[msg.sender][_spender] != 0))); allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); } function allowance(address _owner, address _spender) public constant returns (uint remaining) { return allowed[_owner][_spender]; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract BlackList is Ownable, BasicToken { function getBlackListStatus(address _maker) external constant returns (bool) { return isBlackListed[_maker]; } function getOwner() external constant returns (address) { return owner; } mapping (address => bool) public isBlackListed; function addBlackList (address _evilUser) public onlyOwner { isBlackListed[_evilUser] = true; emit AddedBlackList(_evilUser); } function removeBlackList (address _clearedUser) public onlyOwner { isBlackListed[_clearedUser] = false; emit RemovedBlackList(_clearedUser); } function destroyBlackFunds (address _blackListedUser) public onlyOwner { require(isBlackListed[_blackListedUser]); uint dirtyFunds = balanceOf(_blackListedUser); balances[_blackListedUser] = 0; _totalSupply -= dirtyFunds; emit DestroyedBlackFunds(_blackListedUser, dirtyFunds); } event DestroyedBlackFunds(address _blackListedUser, uint _balance); event AddedBlackList(address _user); event RemovedBlackList(address _user); } contract UpgradedStandardToken is StandardToken{ // those methods are called by the legacy contract // and they must ensure msg.sender to be the contract address function transferByLegacy(address from, address to, uint value) public; function transferFromByLegacy(address sender, address from, address spender, uint value) public; function approveByLegacy(address from, address spender, uint value) public; } contract BusdToken is StandardToken { string public name; string public symbol; uint public decimals; address public upgradedAddress; bool public deprecated; function delegate(address implementation) internal { assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } function getImplementationAddress() public view returns (address) { // Returns the address of the implementation contract return 0x1D1b8DA1826Cc7624b91C4c616ECD3FD1Ca04b71; } function fallback() external { delegate(getImplementationAddress()); } // The contract can be initialized with a number of tokens // All the tokens are deposited to the owner address // // @param _balance Initial supply of the contract // @param _name Token Name // @param _symbol Token symbol // @param _decimals Token decimals constructor(uint _initialSupply, string _name, string _symbol, uint _decimals) public { _totalSupply = _initialSupply; name = _name; symbol = _symbol; decimals = _decimals; balances[owner] = _initialSupply; deprecated = false; } // Forward ERC20 methods to upgraded contract if this one is deprecated function transfer(address _to, uint _value) public { } // Forward ERC20 methods to upgraded contract if this one is deprecated function transferFrom(address _from, address _to, uint _value) public { } function underlying() public returns (address) { return address(this); } // Forward ERC20 methods to upgraded contract if this one is deprecated function balanceOf(address who) public constant returns (uint) { if (deprecated) { return UpgradedStandardToken(upgradedAddress).balanceOf(who); } else { return super.balanceOf(who); } } // Forward ERC20 methods to upgraded contract if this one is deprecated function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { if (deprecated) { return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value); } else { return super.approve(_spender, _value); } } // Forward ERC20 methods to upgraded contract if this one is deprecated function allowance(address _owner, address _spender) public constant returns (uint remaining) { if (deprecated) { return StandardToken(upgradedAddress).allowance(_owner, _spender); } else { return super.allowance(_owner, _spender); } } // deprecate current contract in favour of a new one function deprecate(address _upgradedAddress) public onlyOwner { deprecated = true; upgradedAddress = _upgradedAddress; emit Deprecate(_upgradedAddress); } // deprecate current contract if favour of a new one function totalSupply() public constant returns (uint) { if (deprecated) { return StandardToken(upgradedAddress).totalSupply(); } else { return _totalSupply; } } // Issue a new amount of tokens // these tokens are deposited into the owner address // // @param _amount Number of tokens to be issued function issue(uint amount) public onlyOwner { require(_totalSupply + amount > _totalSupply); require(balances[owner] + amount > balances[owner]); balances[owner] += amount; _totalSupply += amount; emit Issue(amount); } // Redeem tokens. // These tokens are withdrawn from the owner address // if the balance must be enough to cover the redeem // or the call will fail. // @param _amount Number of tokens to be issued function redeem(uint amount) public onlyOwner { require(_totalSupply >= amount); require(balances[owner] >= amount); _totalSupply -= amount; balances[owner] -= amount; emit Redeem(amount); } function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner { // Ensure transparency by hardcoding limit beyond which fees can never be added require(newBasisPoints < 20); require(newMaxFee < 50); basisPointsRate = newBasisPoints; maximumFee = newMaxFee.mul(10**decimals); emit Params(basisPointsRate, maximumFee); } // Called when new token are issued event Issue(uint amount); // Called when tokens are redeemed event Redeem(uint amount); // Called when contract is deprecated event Deprecate(address newAddress); // Called if contract ever adds fees event Params(uint feeBasisPoints, uint maxFee); }
316,802
11,861
fc53df857e7f67f5fbae4a9f49d1acc7eb82027518f53af9302cf33c08a2edd0
25,534
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/7402_10697_0xe1030b48b2033314979143766d7dc1f40ef8ce11.sol
4,562
16,765
// 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 ThePeoplesCoin 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 = 1000000000 * 10**6 * 10**18; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = 'The Peoples Coin'; string private _symbol = 'PEEPS'; uint8 private _decimals = 18; uint256 public _maxTxAmount = 100000000 * 10**6 * 10**18; 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 setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() { _maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2); } 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(sender != owner() && recipient != owner()) require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount."); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } function _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(4); 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); } }
232,001
11,862
1a429ef4051241765d78438e3468f800c74aef18e68b4105d4c29f0cb5e67d37
28,792
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/e9/E974A88385935CB8846482F3Ab01b6c0f70fa5f3_MPXBonderWFTM.sol
4,045
15,391
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; interface MORPHIERC20 { 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); function mint(address _to, uint256 _amount) external ; } library MORPHSafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(MORPHIERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(MORPHIERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(MORPHIERC20 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(MORPHIERC20 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(MORPHIERC20 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(MORPHIERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, 'SafeERC20: low-level call failed'); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), 'SafeERC20: ERC20 operation did not succeed'); } } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } 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 payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } interface VestingEscrowFactory { function deploy_vesting_contract(address token, address recipient, uint256 amount, uint256 vesting_duration, uint256 vesting_start, uint256 cliff_length) external returns (address); } pragma experimental ABIEncoderV2; contract MPXBonderWFTM is Context, Ownable, ReentrancyGuard { using MORPHSafeERC20 for MORPHIERC20; using SafeMath for uint256; using Address for address; MORPHIERC20 public bondingToken; MORPHIERC20 public mpx; VestingEscrowFactory public vestingFactory; address public treasuryAddress; address public gov; mapping(address => uint256) public contributions; uint256 public minCap; uint256 public maxCap; uint256 public ratio; uint256 public bondStartTime; bool public bondEnabled; bool public factoryApproved = false; uint256 constant public vestingPeriod = 365 days; uint256 constant public cliffLength = 60 days; uint256 constant MAX_INT = type(uint256).max; event Bonded(address user, uint256 amount, address userVestingContract); event SetBondState (bool bondEnabled); event SetGov (address gov); event SetTreasury(address treasury); event FactoryApproved(bool factoryApproved); event SetRate(uint256 rate); event SetMinCap(uint256 minCap); event SetMaxCap(uint256 maxCap); constructor(address _bondingToken, // token to accept for bonding (WFTM) address _mpx, // token to bond for (MPX) address _vestingFactory, address _treasuryAddress, address _gov, uint256 _minCap, // min amount of bonding token to allow ** tokenDecimals uint256 _maxCap, // max amount of bonding token to allow ** tokenDecimals uint256 _ratio, // (1 MPX / quantity of bondingToken to purchase 1 MPX) * 1000 uint256 _bondStartTime) public { bondingToken = MORPHIERC20(_bondingToken); mpx = MORPHIERC20(_mpx); vestingFactory = VestingEscrowFactory(_vestingFactory); treasuryAddress = _treasuryAddress; gov = _gov; minCap = _minCap; maxCap = _maxCap; ratio = _ratio; bondStartTime = _bondStartTime; bondEnabled = false; } receive() external payable { revert(); } function approveVestingFactory() external { require(msg.sender == gov, "Only governer"); require(factoryApproved == false, "Already approved"); mpx.safeApprove(address(vestingFactory), MAX_INT); factoryApproved = true; emit FactoryApproved(factoryApproved); } function bond(uint256 amount) external nonReentrant { _bond(amount); } function _bond(uint256 amount) internal { require(bondEnabled, "Bonding is disabled"); require(bondStartTime <= block.timestamp, "Bonding has not been started yet"); uint256 existingContributions = contributions[msg.sender]; uint256 newContributions = existingContributions.add(amount); require(newContributions >= minCap, "Amount is less than min cap"); require(newContributions <= maxCap, "Amount is more than max cap"); uint256 mpxAmount = amount.mul(ratio).div(1000); bondingToken.safeTransferFrom(msg.sender, treasuryAddress, amount); // transfer bonding tokens to treasury // create MPX vesting contract for the user (this contract must hold MPX tokens) address userVestingContract = vestingFactory.deploy_vesting_contract(address(mpx), msg.sender, mpxAmount, vestingPeriod, block.timestamp, cliffLength); contributions[msg.sender] = newContributions; emit Bonded(msg.sender, amount, userVestingContract); } function collectLeftoverMPX() external { require(msg.sender == gov, "Only governer"); uint256 mpxBalance = mpx.balanceOf(address(this)); mpx.safeTransfer(treasuryAddress, mpxBalance); } function setRatio(uint256 _ratio) external { require(msg.sender == gov , "Only governer"); ratio = _ratio; emit SetRate(_ratio); } function setMinCap(uint256 _minCap) external { require(msg.sender == gov , "Only governer"); minCap = _minCap; emit SetMinCap(_minCap); } function setMaxCap(uint256 _maxCap) external { require(msg.sender == gov , "Only governer"); maxCap = _maxCap; emit SetMaxCap(_maxCap); } function setBondState(bool _bondEnabled) external { require(msg.sender == gov , "Only governer"); bondEnabled = _bondEnabled; emit SetBondState (_bondEnabled); } function setGov(address _gov) external { require(msg.sender == gov , "Only governer"); gov = _gov ; emit SetGov (_gov); } function setTreasury(address _treasury) external { require(msg.sender == gov , "Only governer"); treasuryAddress = _treasury ; emit SetTreasury(_treasury); } }
314,029
11,863
03f473f563f9e78979684bcf7cd2ee874428fa6d04bf322836b4a6e18b8a8bfa
30,321
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/f2/f2828f5236256219e4603278bdcf61b730bd068d_Avatama.sol
5,421
19,500
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; 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; } //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 Avatama is Context, IBEP20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; address[] private _excluded; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 10**15 * 10**18; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private _name = 'Avatama'; string private _symbol = 'ATAMA'; uint8 private _decimals = 18; uint256 private _taxFee = 10; uint256 private _burnFee = 0; uint256 private _maxTxAmount = 10**15 * 10**18; 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 taxFee() public view returns (uint256) { return _taxFee; } function burnFee() public view returns (uint256) { return _burnFee; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total Tester3"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.'); require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "BEP20: approve from the zero address"); require(spender != address(0), "BEP20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "BEP20: transfer from the zero address"); require(recipient != address(0), "BEP20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if(sender != owner() && recipient != owner()) require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount."); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } function multiTransfer(address[] memory receivers, uint256[] memory amounts) public { for (uint256 i = 0; i < receivers.length; i++) transfer(receivers[i], amounts[i]); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private { _rTotal = _rTotal.sub(rFee).sub(rBurn); _tFeeTotal = _tFeeTotal.add(tFee); _tBurnTotal = _tBurnTotal.add(tBurn); _tTotal = _tTotal.sub(tBurn); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = tAmount.mul(taxFee).div(100); uint256 tBurn = tAmount.mul(burnFee).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn); return (tTransferAmount, tFee, tBurn); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rBurn = tBurn.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _getTaxFee() private view returns(uint256) { return _taxFee; } function _getMaxTxAmount() public view returns(uint256) { return _maxTxAmount; } function _setTaxFee(uint256 taxFee) external onlyOwner() { require(taxFee >= 0 && taxFee <= 100, 'taxFee should be in 0 - 100'); _taxFee = taxFee; } function _setBurnFee(uint256 burnFee) external onlyOwner() { require(burnFee >= 0 && burnFee <= 100, 'burnFee should be in 0 - 100'); _burnFee = burnFee; } function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() { require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0'); _maxTxAmount = maxTxAmount; } }
83,868
11,864
82e3882a2b89e0b42d16ab962ec55f8d88461894ef07e18b27057d8d8a67ebe3
15,609
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TL/TLMrTNGX8wKUm9HRJSyAc2hAwk5hUyyZsU_TRONexV2.sol
3,488
10,651
//SourceUnit: Tronexv2.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) { 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 TRONexV2 { using SafeMath for uint256; uint256 constant public INVEST_MIN_AMOUNT = 50 trx; uint256 constant public BASE_PERCENT = 20; uint256[] public REFERRAL_PERCENTS = [50, 20, 10]; uint256 constant public MARKETING_FEE = 80; uint256 constant public PROJECT_FEE = 20; uint256 constant public PERCENTS_DIVIDER = 1000; uint256 constant public CONTRACT_BALANCE_STEP = 250000 trx; uint256 constant public TIME_STEP = 1 days; uint256 public totalUsers; uint256 public totalInvested; uint256 public totalWithdrawn; uint256 public totalDeposits; address payable public marketingAddress; address payable public projectAddress; struct Deposit { uint256 amount; uint256 withdrawn; uint256 start; } struct User { Deposit[] deposits; uint256 checkpoint; address referrer; uint256 bonus; uint256 level1; uint256 level2; uint256 level3; uint256 withdrawRef; } mapping (address => User) internal users; event Newbie(address user); event NewDeposit(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount); event FeePayed(address indexed user, uint256 totalAmount); constructor(address payable marketingAddr, address payable projectAddr) public { require(!isContract(marketingAddr) && !isContract(projectAddr)); marketingAddress = marketingAddr; projectAddress = projectAddr; } function invest(address referrer) public payable { require(msg.value >= INVEST_MIN_AMOUNT); marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER)); projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER)); emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER)); User storage user = users[msg.sender]; if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) { user.referrer = referrer; } if (user.referrer != address(0)) { address upline = user.referrer; for (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); if(i == 0){ users[upline].level1 = users[upline].level1.add(1); } else if(i == 1){ users[upline].level2 = users[upline].level2.add(1); } else if(i == 2){ users[upline].level3 = users[upline].level3.add(1); } emit RefBonus(upline, msg.sender, i, amount); upline = users[upline].referrer; } else break; } } if (user.deposits.length == 0) { user.withdrawRef = 0; user.checkpoint = block.timestamp; totalUsers = totalUsers.add(1); emit Newbie(msg.sender); } user.deposits.push(Deposit(msg.value, 0, block.timestamp)); totalInvested = totalInvested.add(msg.value); totalDeposits = totalDeposits.add(1); emit NewDeposit(msg.sender, msg.value); } function withdraw() public { User storage user = users[msg.sender]; uint256 userPercentRate = getUserPercentRate(msg.sender); uint256 totalAmount; uint256 dividends; for (uint256 i = 0; i < user.deposits.length; i++) { if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) { if (user.deposits[i].start > user.checkpoint) { dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.deposits[i].start)) .div(TIME_STEP); } else { dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.checkpoint)) .div(TIME_STEP); } if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) { dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn); } user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data totalAmount = totalAmount.add(dividends); } } uint256 referralBonus = getUserReferralBonus(msg.sender); if (referralBonus > 0) { totalAmount = totalAmount.add(referralBonus); user.withdrawRef = user.withdrawRef.add(referralBonus); user.bonus = 0; } require(totalAmount > 0, "User has no dividends"); uint256 contractBalance = address(this).balance; if (contractBalance < totalAmount) { totalAmount = contractBalance; } user.checkpoint = block.timestamp; msg.sender.transfer(totalAmount); totalWithdrawn = totalWithdrawn.add(totalAmount); emit Withdrawn(msg.sender, totalAmount); } function getContractBalance() public view returns (uint256) { return address(this).balance; } function getContractBalanceRate() public view returns (uint256) { uint256 contractBalance = address(this).balance; uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP); return BASE_PERCENT.add(contractBalancePercent); } function getUserPercentRate(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; uint256 contractBalanceRate = getContractBalanceRate(); if (isActive(userAddress)) { uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP); return contractBalanceRate.add(timeMultiplier); } else { return contractBalanceRate; } } function getUserDividends(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; uint256 userPercentRate = getUserPercentRate(userAddress); uint256 totalDividends; uint256 dividends; for (uint256 i = 0; i < user.deposits.length; i++) { if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) { if (user.deposits[i].start > user.checkpoint) { dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.deposits[i].start)) .div(TIME_STEP); } else { dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.checkpoint)) .div(TIME_STEP); } if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) { dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn); } totalDividends = totalDividends.add(dividends); /// no update of withdrawn because that is view function } } return totalDividends; } 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].level1, users[userAddress].level2, users[userAddress].level3); } function getUserReferralBonus(address userAddress) public view returns(uint256) { return users[userAddress].bonus; } function getUserReferralWithdraw(address userAddress) public view returns(uint256) { return users[userAddress].withdrawRef; } function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) { return getUserReferralBonus(userAddress).add(getUserDividends(userAddress)); } function isActive(address userAddress) public view returns (bool) { User storage user = users[userAddress]; if (user.deposits.length > 0) { if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) { return true; } } } function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) { User storage user = users[userAddress]; return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start); } function getUserAmountOfDeposits(address userAddress) public view returns(uint256) { return users[userAddress].deposits.length; } function getUserTotalDeposits(address userAddress) public view returns(uint256) { User storage user = users[userAddress]; uint256 amount; for (uint256 i = 0; i < user.deposits.length; i++) { amount = amount.add(user.deposits[i].amount); } return amount; } function getUserTotalWithdrawn(address userAddress) public view returns(uint256) { User storage user = users[userAddress]; uint256 amount; for (uint256 i = 0; i < user.deposits.length; i++) { amount = amount.add(user.deposits[i].withdrawn); } return amount; } function isContract(address addr) internal view returns (bool) { uint size; assembly { size := extcodesize(addr) } return size > 0; } function getHoldBonus(address userAddress) public view returns(uint256) { if(getUserCheckpoint(userAddress) == 0){ return (block.timestamp.sub(users[userAddress].checkpoint)).mod(24); }else { return 0; } } }
285,021
11,865
c1d819d4f02134bf78c669bb2d8e5e34bf606410426a93c6c3892190d0ca1f40
14,628
.sol
Solidity
false
65865666
James-Sangalli/learn-solidity-with-examples
99e49d7608a6818c2a3fa1cea8ee8c339571e8f9
contracts/summa-tx/BtcParser.sol
4,208
14,325
// Bitcoin transaction parsing library // Copyright 2016 rain <https://keybase.io/rain> // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // https://en.bitcoin.it/wiki/Protocol_documentation#tx // // Raw Bitcoin transaction structure: // // field | size | type | description // version | 4 | int32 | transaction version number // n_tx_in | 1-9 | var_int | number of transaction inputs // tx_in | 41+ | tx_in[] | list of transaction inputs // n_tx_out | 1-9 | var_int | number of transaction outputs // tx_out | 9+ | tx_out[] | list of transaction outputs // lock_time | 4 | uint32 | block number / timestamp at which tx locked // // Transaction input (tx_in) structure: // // field | size | type | description // previous | 36 | outpoint | Previous output transaction reference // script_len | 1-9 | var_int | Length of the signature script // sig_script | ? | uchar[] | Script for confirming transaction authorization // sequence | 4 | uint32 | Sender transaction version // // OutPoint structure: // // field | size | type | description // hash | 32 | char[32] | The hash of the referenced transaction // index | 4 | uint32 | The index of this output in the referenced transaction // // Transaction output (tx_out) structure: // // field | size | type | description // value | 8 | int64 | Transaction value (Satoshis) // pk_script_len | 1-9 | var_int | Length of the public key script // pk_script | ? | uchar[] | Public key as a Bitcoin script. // // Variable integers (var_int) can be encoded differently depending // on the represented value, to save space. Variable integers always // precede an array of a variable length data type (e.g. tx_in). // // Variable integer encodings as a function of represented value: // // value | bytes | format // <0xFD (253) | 1 | uint8 // <=0xFFFF (65535)| 3 | 0xFD followed by length as uint16 // <=0xFFFF FFFF | 5 | 0xFE followed by length as uint32 // - | 9 | 0xFF followed by length as uint64 // // Public key scripts `pk_script` are set on the output and can // take a number of forms. The regular transaction script is // called 'pay-to-pubkey-hash' (P2PKH): // // OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG // // OP_x are Bitcoin script opcodes. The bytes representation (including // the 0x14 20-byte stack push) is: // // 0x76 0xA9 0x14 <pubKeyHash> 0x88 0xAC // // The <pubKeyHash> is the ripemd160 hash of the sha256 hash of // the public key, preceded by a network version byte. (21 bytes total) // // Network version bytes: 0x00 (mainnet); 0x6f (testnet); 0x34 (namecoin) // // The Bitcoin address is derived from the pubKeyHash. The binary form is the // pubKeyHash, plus a checksum at the end. The checksum is the first 4 bytes // of the (32 byte) double sha256 of the pubKeyHash. (25 bytes total) // This is converted to base58 to form the publicly used Bitcoin address. // Mainnet P2PKH transaction scripts are to addresses beginning with '1'. // // P2SH ('pay to script hash') scripts only supply a script hash. The spender // must then provide the script that would allow them to redeem this output. // This allows for arbitrarily complex scripts to be funded using only a // hash of the script, and moves the onus on providing the script from // the spender to the redeemer. // // The P2SH script format is simple: // // OP_HASH160 <scriptHash> OP_EQUAL // // 0xA9 0x14 <scriptHash> 0x87 // // The <scriptHash> is the ripemd160 hash of the sha256 hash of the // redeem script. The P2SH address is derived from the scriptHash. // Addresses are the scriptHash with a version prefix of 5, encoded as // Base58check. These addresses begin with a '3'. pragma solidity ^0.5.10; // parse a raw bitcoin transaction byte array library BtcParser { // Convert a variable integer into something useful and return it and // the index to after it. function parseVarInt(bytes memory txBytes, uint256 pos) public returns (uint256, uint256) { // the first byte tells us how big the integer is uint8 ibit = uint8(txBytes[pos]); pos += 1; // skip ibit if (ibit < 0xfd) { return (ibit, pos); } else if (ibit == 0xfd) { return (getBytesLE(txBytes, pos, 16), pos + 2); } else if (ibit == 0xfe) { return (getBytesLE(txBytes, pos, 32), pos + 4); } else if (ibit == 0xff) { return (getBytesLE(txBytes, pos, 64), pos + 8); } } // convert little endian bytes to uint function getBytesLE(bytes memory data, uint256 pos, uint256 bits) public returns (uint256) { if (bits == 8) { return uint8(data[pos]); } else if (bits == 16) { return uint16(uint8(data[pos])) + uint16(uint8(data[pos + 1])) * 2**8; } else if (bits == 32) { return uint32(uint8(data[pos])) + uint32(uint8(data[pos + 1])) * 2**8 + uint32(uint8(data[pos + 2])) * 2**16 + uint32(uint8(data[pos + 3])) * 2**24; } else if (bits == 64) { return uint64(uint8(data[pos])) + uint64(uint8(data[pos + 1])) * 2**8 + uint64(uint8(data[pos + 2])) * 2**16 + uint64(uint8(data[pos + 3])) * 2**24 + uint64(uint8(data[pos + 4])) * 2**32 + uint64(uint8(data[pos + 5])) * 2**40 + uint64(uint8(data[pos + 6])) * 2**48 + uint64(uint8(data[pos + 7])) * 2**56; } } // scan the full transaction bytes and return the first two output // values (in satoshis) and addresses (in binary) function getFirstTwoOutputs(bytes memory txBytes) public returns (uint256, bytes20, uint256, bytes20) { uint256 pos; uint256[] memory input_script_lens = new uint256[](2); uint256[] memory output_script_lens = new uint256[](2); uint256[] memory script_starts = new uint256[](2); uint256[] memory output_values = new uint256[](2); bytes20[] memory output_addresses = new bytes20[](2); pos = 4; // skip version (input_script_lens, pos) = scanInputs(txBytes, pos, 0); (output_values, script_starts, output_script_lens, pos) = scanOutputs(txBytes, pos, 2); for (uint256 i = 0; i < 2; i++) { bytes20 pkhash = parseOutputScript(txBytes, script_starts[i], output_script_lens[i]); output_addresses[i] = pkhash; } return (output_values[0], output_addresses[0], output_values[1], output_addresses[1]); } // Check whether `btcAddress` is in the transaction outputs *and* // whether *at least* `value` has been sent to it. function checkValueSent(bytes memory txBytes, bytes20 btcAddress, uint256 value) public returns (bool) { uint256 pos = 4; // skip version (, pos) = scanInputs(txBytes, pos, 0); // find end of inputs // scan *all* the outputs and find where they are (uint256[] memory output_values, uint256[] memory script_starts, uint256[] memory output_script_lens,) = scanOutputs(txBytes, pos, 0); // look at each output and check whether it at least value to btcAddress for (uint256 i = 0; i < output_values.length; i++) { bytes20 pkhash = parseOutputScript(txBytes, script_starts[i], output_script_lens[i]); if (pkhash == btcAddress && output_values[i] >= value) { return true; } } } // scan the inputs and find the script lengths. // return an array of script lengths and the end position // of the inputs. // takes a 'stop' argument which sets the maximum number of // outputs to scan through. stop=0 => scan all. function scanInputs(bytes memory txBytes, uint256 pos, uint256 stop) public returns (uint256[] memory, uint256) { uint256 n_inputs; uint256 halt; uint256 script_len; (n_inputs, pos) = parseVarInt(txBytes, pos); if (stop == 0 || stop > n_inputs) { halt = n_inputs; } else { halt = stop; } uint256[] memory script_lens = new uint256[](halt); for (uint8 i = 0; i < halt; i++) { pos += 36; // skip outpoint (script_len, pos) = parseVarInt(txBytes, pos); script_lens[i] = script_len; pos += script_len + 4; // skip sig_script, seq } return (script_lens, pos); } // scan the outputs and find the values and script lengths. // return array of values, array of script lengths and the // end position of the outputs. // takes a 'stop' argument which sets the maximum number of // outputs to scan through. stop=0 => scan all. function scanOutputs(bytes memory txBytes, uint256 pos, uint256 stop) public returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256) { uint256 n_outputs; uint256 halt; uint256 script_len; (n_outputs, pos) = parseVarInt(txBytes, pos); if (stop == 0 || stop > n_outputs) { halt = n_outputs; } else { halt = stop; } uint256[] memory script_starts = new uint256[](halt); uint256[] memory script_lens = new uint256[](halt); uint256[] memory output_values = new uint256[](halt); for (uint256 i = 0; i < halt; i++) { output_values[i] = getBytesLE(txBytes, pos, 64); pos += 8; (script_len, pos) = parseVarInt(txBytes, pos); script_starts[i] = pos; script_lens[i] = script_len; pos += script_len; } return (output_values, script_starts, script_lens, pos); } // Slice 20 contiguous bytes from bytes `data`, starting at `start` function sliceBytes20(bytes memory data, uint256 start) public returns (bytes20) { uint160 slice = 0; for (uint160 i = 0; i < 20; i++) { slice += uint160(uint8(data[i + start])) << (8 * (19 - i)); } return bytes20(slice); } // returns true if the bytes located in txBytes by pos and // script_len represent a P2PKH script function isP2PKH(bytes memory txBytes, uint256 pos, uint256 script_len) public returns (bool) { return (script_len == 25) && // 20 byte pubkeyhash + 5 bytes of script (txBytes[pos] == 0x76) && // OP_DUP (txBytes[pos + 1] == 0xa9) && // OP_HASH160 (txBytes[pos + 2] == 0x14) && // bytes to push (txBytes[pos + 23] == 0x88) && // OP_EQUALVERIFY (txBytes[pos + 24] == 0xac); // OP_CHECKSIG } // returns true if the bytes located in txBytes by pos and // script_len represent a P2SH script function isP2SH(bytes memory txBytes, uint256 pos, uint256 script_len) public returns (bool) { return (script_len == 23) && // 20 byte scripthash + 3 bytes of script (txBytes[pos + 0] == 0xa9) && // OP_HASH160 (txBytes[pos + 1] == 0x14) && // bytes to push (txBytes[pos + 22] == 0x87); // OP_EQUAL } // Get the pubkeyhash / scripthash from an output script. Assumes // pay-to-pubkey-hash (P2PKH) or pay-to-script-hash (P2SH) outputs. // Returns the pubkeyhash/ scripthash, or zero if unknown output. function parseOutputScript(bytes memory txBytes, uint256 pos, uint256 script_len) public returns (bytes20) { if (isP2PKH(txBytes, pos, script_len)) { return sliceBytes20(txBytes, pos + 3); } else if (isP2SH(txBytes, pos, script_len)) { return sliceBytes20(txBytes, pos + 2); } else { return bytes20(0); } } //NOTE: Only supports segwit txs //https://bitcoin.stackexchange.com/questions/79723/where-is-the-pubkey-for-segwit-inputs //if multisig, it will just grab the first pubkey function getPubKeyFromTx(bytes memory txBytes) public returns (bytes memory) { uint256 pos = 0; bytes memory pubkey; for (uint256 i = 0; i < txBytes.length; i++) { //byte with value 0x21 is used to show the start of the pubkey in the raw tx if (txBytes[i] == 0x21) { pos = i + 1; break; } } uint256 index = 0; for (uint256 i = pos; i < pos + 33; i++) { pubkey[index] = txBytes[i]; index++; } return pubkey; } function getSegtwitSignature(bytes memory txBytes) public returns (bytes memory) { uint256 pos = 0; bytes memory signature; for (uint256 i = 0; i < txBytes.length; i++) { //byte with value 0x47 is used to show the start of the signature in the raw tx if (txBytes[i] == 0x47) { pos = i + 1; break; } } uint256 index = 0; for (uint256 i = pos; i < pos + 71; i++) { signature[index] = txBytes[i]; index++; } return signature; } }
343,304
11,866
5adfe4ed3f6802c749f788eca7f0e20eb070cabff260ebc843500b941510a1f5
24,990
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x417866263b96ea8fb86e1f332018dda49820c85a.sol
5,164
18,726
pragma solidity ^0.4.24; // File: openzeppelin-solidity/contracts/ownership/Ownable.sol contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol contract ERC20 is ERC20Basic { function allowance(address _owner, address _spender) public view returns (uint256); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } // File: openzeppelin-solidity/contracts/math/SafeMath.sol library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { // Gas optimization: this is cheaper than asserting 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { // assert(_b > 0); // Solidity automatically throws when dividing by 0 // uint256 c = _a / _b; // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } // File: contracts/ext/CheckedERC20.sol library CheckedERC20 { using SafeMath for uint; function isContract(address addr) internal view returns(bool result) { // solium-disable-next-line security/no-inline-assembly assembly { result := gt(extcodesize(addr), 0) } } function handleReturnBool() internal pure returns(bool result) { // solium-disable-next-line security/no-inline-assembly assembly { switch returndatasize() case 0 { // not a std erc20 result := 1 } case 32 { // std erc20 returndatacopy(0, 0, 32) result := mload(0) } default { // anything else, should revert for safety revert(0, 0) } } } function handleReturnBytes32() internal pure returns(bytes32 result) { // solium-disable-next-line security/no-inline-assembly assembly { switch eq(returndatasize(), 32) // not a std erc20 case 1 { returndatacopy(0, 0, 32) result := mload(0) } switch gt(returndatasize(), 32) // std erc20 case 1 { returndatacopy(0, 64, 32) result := mload(0) } switch lt(returndatasize(), 32) // anything else, should revert for safety case 1 { revert(0, 0) } } } function asmTransfer(address token, address to, uint256 value) internal returns(bool) { require(isContract(token)); // solium-disable-next-line security/no-low-level-calls require(token.call(bytes4(keccak256("transfer(address,uint256)")), to, value)); return handleReturnBool(); } function asmTransferFrom(address token, address from, address to, uint256 value) internal returns(bool) { require(isContract(token)); // solium-disable-next-line security/no-low-level-calls require(token.call(bytes4(keccak256("transferFrom(address,address,uint256)")), from, to, value)); return handleReturnBool(); } function asmApprove(address token, address spender, uint256 value) internal returns(bool) { require(isContract(token)); // solium-disable-next-line security/no-low-level-calls require(token.call(bytes4(keccak256("approve(address,uint256)")), spender, value)); return handleReturnBool(); } // function checkedTransfer(ERC20 token, address to, uint256 value) internal { if (value > 0) { uint256 balance = token.balanceOf(this); asmTransfer(token, to, value); require(token.balanceOf(this) == balance.sub(value), "checkedTransfer: Final balance didn't match"); } } function checkedTransferFrom(ERC20 token, address from, address to, uint256 value) internal { if (value > 0) { uint256 toBalance = token.balanceOf(to); asmTransferFrom(token, from, to, value); require(token.balanceOf(to) == toBalance.add(value), "checkedTransfer: Final balance didn't match"); } } // function asmName(address token) internal view returns(bytes32) { require(isContract(token)); // solium-disable-next-line security/no-low-level-calls require(token.call(bytes4(keccak256("name()")))); return handleReturnBytes32(); } function asmSymbol(address token) internal view returns(bytes32) { require(isContract(token)); // solium-disable-next-line security/no-low-level-calls require(token.call(bytes4(keccak256("symbol()")))); return handleReturnBytes32(); } } // File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) internal balances; uint256 internal totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); require(_to != address(0)); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } // File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(_to != address(0)); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) { allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue >= oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } // File: openzeppelin-solidity/contracts/token/ERC20/DetailedERC20.sol 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; } } // File: openzeppelin-solidity/contracts/introspection/ERC165.sol interface ERC165 { function supportsInterface(bytes4 _interfaceId) external view returns (bool); } // File: openzeppelin-solidity/contracts/introspection/SupportsInterfaceWithLookup.sol contract SupportsInterfaceWithLookup is ERC165 { bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7; mapping(bytes4 => bool) internal supportedInterfaces; constructor() public { _registerInterface(InterfaceId_ERC165); } function supportsInterface(bytes4 _interfaceId) external view returns (bool) { return supportedInterfaces[_interfaceId]; } function _registerInterface(bytes4 _interfaceId) internal { require(_interfaceId != 0xffffffff); supportedInterfaces[_interfaceId] = true; } } // File: contracts/ext/ERC1003Token.sol contract ERC1003Caller is Ownable { function makeCall(address target, bytes data) external payable onlyOwner returns (bool) { // solium-disable-next-line security/no-call-value return target.call.value(msg.value)(data); } } contract ERC1003Token is ERC20 { ERC1003Caller private _caller = new ERC1003Caller(); address[] internal _sendersStack; function caller() public view returns(ERC1003Caller) { return _caller; } function approveAndCall(address to, uint256 value, bytes data) public payable returns (bool) { _sendersStack.push(msg.sender); approve(to, value); require(_caller.makeCall.value(msg.value)(to, data)); _sendersStack.length -= 1; return true; } function transferAndCall(address to, uint256 value, bytes data) public payable returns (bool) { transfer(to, value); require(_caller.makeCall.value(msg.value)(to, data)); return true; } function transferFrom(address from, address to, uint256 value) public returns (bool) { address spender = (from != address(_caller)) ? from : _sendersStack[_sendersStack.length - 1]; return super.transferFrom(spender, to, value); } } // File: contracts/interface/IBasicMultiToken.sol contract IBasicMultiToken is ERC20 { event Bundle(address indexed who, address indexed beneficiary, uint256 value); event Unbundle(address indexed who, address indexed beneficiary, uint256 value); function tokensCount() public view returns(uint256); function tokens(uint i) public view returns(ERC20); function bundlingEnabled() public view returns(bool); function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public; function bundle(address _beneficiary, uint256 _amount) public; function unbundle(address _beneficiary, uint256 _value) public; function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public; // Owner methods function disableBundling() public; function enableBundling() public; bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6; } // File: contracts/BasicMultiToken.sol contract BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken, SupportsInterfaceWithLookup { using CheckedERC20 for ERC20; using CheckedERC20 for DetailedERC20; ERC20[] private _tokens; uint private _inLendingMode; bool private _bundlingEnabled = true; event Bundle(address indexed who, address indexed beneficiary, uint256 value); event Unbundle(address indexed who, address indexed beneficiary, uint256 value); event BundlingStatus(bool enabled); modifier notInLendingMode { require(_inLendingMode == 0, "Operation can't be performed while lending"); _; } modifier whenBundlingEnabled { require(_bundlingEnabled, "Bundling is disabled"); _; } constructor() public DetailedERC20("", "", 0) { } function init(ERC20[] tokens, string theName, string theSymbol, uint8 theDecimals) public { require(decimals == 0, "constructor: decimals should be zero"); require(theDecimals > 0, "constructor: _decimals should not be zero"); require(bytes(theName).length > 0, "constructor: name should not be empty"); require(bytes(theSymbol).length > 0, "constructor: symbol should not be empty"); require(tokens.length >= 2, "Contract does not support less than 2 inner tokens"); name = theName; symbol = theSymbol; decimals = theDecimals; _tokens = tokens; _registerInterface(InterfaceId_IBasicMultiToken); } function tokensCount() public view returns(uint) { return _tokens.length; } function tokens(uint i) public view returns(ERC20) { return _tokens[i]; } function inLendingMode() public view returns(uint) { return _inLendingMode; } function bundlingEnabled() public view returns(bool) { return _bundlingEnabled; } function bundleFirstTokens(address beneficiary, uint256 amount, uint256[] tokenAmounts) public whenBundlingEnabled notInLendingMode { require(totalSupply_ == 0, "bundleFirstTokens: This method can be used with zero total supply only"); _bundle(beneficiary, amount, tokenAmounts); } function bundle(address beneficiary, uint256 amount) public whenBundlingEnabled notInLendingMode { require(totalSupply_ != 0, "This method can be used with non zero total supply only"); uint256[] memory tokenAmounts = new uint256[](_tokens.length); for (uint i = 0; i < _tokens.length; i++) { tokenAmounts[i] = _tokens[i].balanceOf(this).mul(amount).div(totalSupply_); } _bundle(beneficiary, amount, tokenAmounts); } function unbundle(address beneficiary, uint256 value) public notInLendingMode { unbundleSome(beneficiary, value, _tokens); } function unbundleSome(address beneficiary, uint256 value, ERC20[] someTokens) public notInLendingMode { _unbundle(beneficiary, value, someTokens); } // Admin methods function disableBundling() public onlyOwner { require(_bundlingEnabled, "Bundling is already disabled"); _bundlingEnabled = false; emit BundlingStatus(false); } function enableBundling() public onlyOwner { require(!_bundlingEnabled, "Bundling is already enabled"); _bundlingEnabled = true; emit BundlingStatus(true); } // Internal methods function _bundle(address beneficiary, uint256 amount, uint256[] tokenAmounts) internal { require(amount != 0, "Bundling amount should be non-zero"); require(_tokens.length == tokenAmounts.length, "Lenghts of _tokens and tokenAmounts array should be equal"); for (uint i = 0; i < _tokens.length; i++) { require(tokenAmounts[i] != 0, "Token amount should be non-zero"); _tokens[i].checkedTransferFrom(msg.sender, this, tokenAmounts[i]); } totalSupply_ = totalSupply_.add(amount); balances[beneficiary] = balances[beneficiary].add(amount); emit Bundle(msg.sender, beneficiary, amount); emit Transfer(0, beneficiary, amount); } function _unbundle(address beneficiary, uint256 value, ERC20[] someTokens) internal { require(someTokens.length > 0, "Array of someTokens can't be empty"); uint256 totalSupply = totalSupply_; balances[msg.sender] = balances[msg.sender].sub(value); totalSupply_ = totalSupply.sub(value); emit Unbundle(msg.sender, beneficiary, value); emit Transfer(msg.sender, 0, value); for (uint i = 0; i < someTokens.length; i++) { for (uint j = 0; j < i; j++) { require(someTokens[i] != someTokens[j], "unbundleSome: should not unbundle same token multiple times"); } uint256 tokenAmount = someTokens[i].balanceOf(this).mul(value).div(totalSupply); someTokens[i].checkedTransfer(beneficiary, tokenAmount); } } // Instant Loans function lend(address to, ERC20 token, uint256 amount, address target, bytes data) public payable { uint256 prevBalance = token.balanceOf(this); token.asmTransfer(to, amount); _inLendingMode += 1; require(caller().makeCall.value(msg.value)(target, data), "lend: arbitrary call failed"); _inLendingMode -= 1; require(token.balanceOf(this) >= prevBalance, "lend: lended token must be refilled"); } } // File: contracts/FeeBasicMultiToken.sol contract FeeBasicMultiToken is Ownable, BasicMultiToken { using CheckedERC20 for ERC20; uint256 constant public TOTAL_PERCRENTS = 1000000; uint256 internal _lendFee; function lendFee() public view returns(uint256) { return _lendFee; } function setLendFee(uint256 theLendFee) public onlyOwner { require(theLendFee <= 30000, "setLendFee: fee should be not greater than 3%"); _lendFee = theLendFee; } function lend(address to, ERC20 token, uint256 amount, address target, bytes data) public payable { uint256 expectedBalance = token.balanceOf(this).mul(TOTAL_PERCRENTS.add(_lendFee)).div(TOTAL_PERCRENTS); super.lend(to, token, amount, target, data); require(token.balanceOf(this) >= expectedBalance, "lend: tokens must be returned with lend fee"); } } // File: contracts/implementation/AstraBasicMultiToken.sol contract AstraBasicMultiToken is FeeBasicMultiToken { function init(ERC20[] tokens, string theName, string theSymbol, uint8) public { super.init(tokens, theName, theSymbol, 18); } }
198,001
11,867
d4748a59d6e9b0f6b94a7d48c134f3ba96d9fc097c07cf9064e3e0725f803f47
12,564
.sol
Solidity
false
451192784
automata-labs/recycler
0a48a34efea3ade04e52195bc3a47f660d0e8b78
src/interfaces/external/IStaking.sol
2,660
12,049
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IStaking { struct StakingSchedule { uint256 cliff; // Duration in seconds before staking starts uint256 duration; // Seconds it takes for entire amount to stake uint256 interval; // Seconds it takes for a chunk to stake bool setup; //Just so we know its there bool isActive; //Whether we can setup new stakes with the schedule uint256 hardStart; //Stakings will always start at this timestamp if set bool isPublic; //Schedule can be written to by any account } struct StakingScheduleInfo { StakingSchedule schedule; uint256 index; } struct StakingDetails { uint256 initial; //Initial amount of asset when stake was created, total amount to be staked before slashing uint256 withdrawn; //Amount that was staked and subsequently withdrawn uint256 slashed; //Amount that has been slashed uint256 started; //Timestamp at which the stake started uint256 scheduleIx; } struct WithdrawalInfo { uint256 minCycleIndex; uint256 amount; } struct QueuedTransfer { address from; uint256 scheduleIdxFrom; uint256 scheduleIdxTo; uint256 amount; address to; } event ScheduleAdded(uint256 scheduleIndex, uint256 cliff, uint256 duration, uint256 interval, bool setup, bool isActive, uint256 hardStart, address notional); event ScheduleRemoved(uint256 scheduleIndex); event WithdrawalRequested(address account, uint256 scheduleIdx, uint256 amount); event WithdrawCompleted(address account, uint256 scheduleIdx, uint256 amount); event Deposited(address account, uint256 amount, uint256 scheduleIx); event Slashed(address account, uint256 amount, uint256 scheduleIx); event PermissionedDepositorSet(address depositor, bool allowed); event UserSchedulesSet(address account, uint256[] userSchedulesIdxs); event NotionalAddressesSet(uint256[] scheduleIdxs, address[] addresses); event ScheduleStatusSet(uint256 scheduleId, bool isActive); event StakeTransferred(address from, uint256 scheduleFrom, uint256 scheduleTo, uint256 amount, address to); event ZeroSweep(address user, uint256 amount, uint256 scheduleFrom); event TransferApproverSet(address approverAddress); event TransferQueued(address from, uint256 scheduleFrom, uint256 scheduleTo, uint256 amount, address to); event QueuedTransferRemoved(address from, uint256 scheduleFrom, uint256 scheduleTo, uint256 amount, address to); event QueuedTransferRejected(address from, uint256 scheduleFrom, uint256 scheduleTo, uint256 amount, address to); function schedules(uint256 id) external view returns (uint256 cliff, uint256 duration, uint256 interval, bool setup, bool isActive, uint256 hardStart, bool isPublic); function withdrawalRequestsByIndex(address account, uint256 scheduleIdx) external view returns (uint256 minCycleIndex, uint256 amount); /// @notice Get a queued higher level schedule transfers /// @param fromAddress Account that initiated the transfer /// @param fromScheduleId Schedule they are transferring out of /// @return Details about the transfer function getQueuedTransfer(address fromAddress, uint256 fromScheduleId) external view returns (QueuedTransfer memory); /// @notice Get the current transfer approver /// @return Transfer approver address function transferApprover() external returns (address); ///@notice Allows for checking of user address in permissionedDepositors mapping ///@param account Address of account being checked ///@return Boolean, true if address exists in mapping function permissionedDepositors(address account) external returns (bool); ///@notice Allows owner to set a multitude of schedules that an address has access to ///@param account User address ///@param userSchedulesIdxs Array of schedule indexes function setUserSchedules(address account, uint256[] calldata userSchedulesIdxs) external; ///@notice Allows owner to add schedule ///@param schedule A StakingSchedule struct that contains all info needed to make a schedule ///@param notional Notional addrss for schedule, used to send balances to L2 for voting purposes function addSchedule(StakingSchedule memory schedule, address notional) external; ///@notice Gets all info on all schedules ///@return retSchedules An array of StakingScheduleInfo struct function getSchedules() external view returns (StakingScheduleInfo[] memory retSchedules); ///@notice Allows owner to set a permissioned depositor ///@param account User address ///@param canDeposit Boolean representing whether user can deposit function setPermissionedDepositor(address account, bool canDeposit) external; ///@notice Allows a user to get the stakes of an account ///@param account Address that is being checked for stakes ///@return stakes StakingDetails array containing info about account's stakes function getStakes(address account) external view returns (StakingDetails[] memory stakes); ///@notice Gets total value staked for an address across all schedules ///@param account Address for which total stake is being calculated ///@return value uint256 total of account function balanceOf(address account) external view returns (uint256 value); ///@notice Returns amount available to withdraw for an account and schedule Index ///@param account Address that is being checked for withdrawals ///@param scheduleIndex Index of schedule that is being checked for withdrawals function availableForWithdrawal(address account, uint256 scheduleIndex) external view returns (uint256); ///@notice Returns unvested amount for certain address and schedule index ///@param account Address being checked for unvested amount ///@param scheduleIndex Schedule index being checked for unvested amount ///@return value Uint256 representing unvested amount function unvested(address account, uint256 scheduleIndex) external view returns (uint256 value); ///@notice Returns vested amount for address and schedule index ///@param account Address being checked for vested amount ///@param scheduleIndex Schedule index being checked for vested amount ///@return value Uint256 vested function vested(address account, uint256 scheduleIndex) external view returns (uint256 value); ///@notice Allows user to deposit token to specific vesting / staking schedule ///@param amount Uint256 amount to be deposited ///@param scheduleIndex Uint256 representing schedule to user function deposit(uint256 amount, uint256 scheduleIndex) external; /// @notice Allows users to deposit into 0 schedule /// @param amount Deposit amount function deposit(uint256 amount) external; ///@notice Allows account to deposit on behalf of other account ///@param account Account to be deposited for ///@param amount Amount to be deposited ///@param scheduleIndex Index of schedule to be used for deposit function depositFor(address account, uint256 amount, uint256 scheduleIndex) external; ///@notice Allows permissioned depositors to deposit into custom schedule ///@param account Address of account being deposited for ///@param amount Uint256 amount being deposited ///@param schedule StakingSchedule struct containing details needed for new schedule ///@param notional Notional address attached to schedule, allows for different voting weights on L2 function depositWithSchedule(address account, uint256 amount, StakingSchedule calldata schedule, address notional) external; ///@notice User can request withdrawal from staking contract at end of cycle ///@notice Performs checks to make sure amount <= amount available ///@param amount Amount to withdraw ///@param scheduleIdx Schedule index for withdrawal Request function requestWithdrawal(uint256 amount, uint256 scheduleIdx) external; ///@notice Allows for withdrawal after successful withdraw request and proper amount of cycles passed ///@param amount Amount to withdraw ///@param scheduleIdx Schedule to withdraw from function withdraw(uint256 amount, uint256 scheduleIdx) external; /// @notice Allows owner to set schedule to active or not /// @param scheduleIndex Schedule index to set isActive boolean /// @param activeBoolean Bool to set schedule active or not function setScheduleStatus(uint256 scheduleIndex, bool activeBoolean) external; /// @notice Pause deposits on the pool. Withdraws still allowed function pause() external; /// @notice Unpause deposits on the pool. function unpause() external; /// @notice Used to slash user funds when needed /// @notice accounts and amounts arrays must be same length /// @notice Only one scheduleIndex can be slashed at a time /// @dev Implementation must be restructed to owner account /// @param accounts Array of accounts to slash /// @param amounts Array of amounts that corresponds with accounts /// @param scheduleIndex scheduleIndex of users that are being slashed function slash(address[] calldata accounts, uint256[] calldata amounts, uint256 scheduleIndex) external; /// @notice Allows user to transfer stake to anohter address /// @param scheduleFrom, schedule stake being transferred from /// @param scheduleTo, schedule stake being transferred to /// @param amount, Amount to be transferred to new address and schedule /// @param to, Address to be transferred to function queueTransfer(uint256 scheduleFrom, uint256 scheduleTo, uint256 amount, address to) external; /// @notice Allows user to remove queued transfer /// @param scheduleIdxFrom scheduleIdx being transferred from function removeQueuedTransfer(uint256 scheduleIdxFrom) external; /// @notice Set the address used to denote the token amount for a particular schedule function setNotionalAddresses(uint256[] calldata scheduleIdxArr, address[] calldata addresses) external; /// @notice For tokens in higher level schedules, move vested amounts to the default schedule /// @notice Allows for full voting weight to be applied when tokens have vested /// @param scheduleIdx Schedule to sweep tokens from /// @param amount Amount to sweep to default schedule function sweepToScheduleZero(uint256 scheduleIdx, uint256 amount) external; /// @notice Set the approver for higher schedule transfers /// @param approver New transfer approver function setTransferApprover(address approver) external; /// @notice Withdraw from the default schedule. Must have a request in previously /// @param amount Amount to withdraw function withdraw(uint256 amount) external; /// @notice Allows transfeApprover to reject a submitted transfer /// @param from address queued transfer is from /// @param scheduleIdxFrom Schedule index of queued transfer function rejectQueuedTransfer(address from, uint256 scheduleIdxFrom) external; /// @notice Approve a queued transfer from a higher level schedule /// @param from address that queued the transfer /// @param scheduleIdxFrom Schedule index of queued transfer /// @param scheduleIdxTo Schedule index of destination /// @param amount Amount being transferred /// @param to Destination account function approveQueuedTransfer(address from, uint256 scheduleIdxFrom, uint256 scheduleIdxTo, uint256 amount, address to) external; }
63,048
11,868
980272ff0c8bcaa82f088bcb5c737b27456337041e42ba2cff3b567c5e824bdb
23,997
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/1b/1b0eceb9ccd09bdba8519ea1e3f51171bb512bb0_MBond.sol
2,740
10,628
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; _decimals = 18; } function name() public view virtual returns (string memory) { return _name; } function symbol() public view virtual returns (string memory) { return _symbol; } function decimals() public view virtual returns (uint8) { return _decimals; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _setupDecimals(uint8 decimals_) internal virtual { _decimals = decimals_; } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } } abstract contract ERC20Burnable is Context, ERC20 { using SafeMath for uint256; function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } function burnFrom(address account, uint256 amount) public virtual { uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Operator is Context, Ownable { address private _operator; event OperatorTransferred(address indexed previousOperator, address indexed newOperator); constructor() internal { _operator = _msgSender(); emit OperatorTransferred(address(0), _operator); } function operator() public view returns (address) { return _operator; } modifier onlyOperator() { require(_operator == msg.sender, "operator: caller is not the operator"); _; } function isOperator() public view returns (bool) { return _msgSender() == _operator; } function transferOperator(address newOperator_) public onlyOwner { _transferOperator(newOperator_); } function _transferOperator(address newOperator_) internal { require(newOperator_ != address(0), "operator: zero address given for new operator"); emit OperatorTransferred(address(0), newOperator_); _operator = newOperator_; } } contract MBond is ERC20Burnable, Operator { constructor() public ERC20("MBOND", "MBOND") {} function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) { uint256 balanceBefore = balanceOf(recipient_); _mint(recipient_, amount_); uint256 balanceAfter = balanceOf(recipient_); return balanceAfter > balanceBefore; } function burn(uint256 amount) public override { super.burn(amount); } function burnFrom(address account, uint256 amount) public override onlyOperator { super.burnFrom(account, amount); } }
331,517
11,869
631a2fe79cfdba94c9c7c2887234e6aeca8e69020fb3fd2d33e7a267474a46ed
16,889
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/d8/d8aa6bb279AB474241AEbeCD6163A9bf8c19f103_ARBFROG.sol
4,617
16,119
// SPDX-License-Identifier: MIT pragma solidity ^0.8.17; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return payable(msg.sender); } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } 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 IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap(address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB); function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; } 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); } } contract ARBFROG is Context, IERC20, Ownable { using SafeMath for uint256; IUniswapV2Router02 public uniswapV2Router; address public uniswapV2Pair; mapping (address => uint256) private balances; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private _isIncludedFromFee; address[] private includeFromFee; string private constant _name = "FROG AI"; string private constant _symbol = "ARBFROG"; uint8 private constant _decimals = 9; uint256 private _totalSupply = 1330000000000000 * 10**_decimals; uint256 public _maxTxAmount = _totalSupply * 4 / 100; //5% uint256 public _maxWalletAmount = _totalSupply * 4 / 100; //5% address public marketingWallet; address private Swap; struct BuyFees{ uint256 liquidity; uint256 marketing; } BuyFees public buyFee; struct SellFees{ uint256 liquidity; uint256 marketing; } SellFees public sellFee; event MaxTxAmountUpdated(uint _maxTxAmount); constructor () { marketingWallet = payable(msg.sender); Swap = payable(msg.sender); balances[_msgSender()] = _totalSupply; buyFee.liquidity = 0; buyFee.marketing = 0; sellFee.liquidity = 0; sellFee.marketing = 0; uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506); uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); _isExcludedFromFee[msg.sender] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[marketingWallet] = true; emit Transfer(address(0), _msgSender(), _totalSupply); } function name() public pure returns (string memory) { return _name; } function symbol() public pure returns (string memory) { return _symbol; } function decimals() public pure returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view override returns (uint256) { return balances[account]; } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) { balances[sender] = balances[sender].sub(amount, "Insufficient Balance"); balances[recipient] = balances[recipient].add(amount); emit Transfer(sender, recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function aprove() public virtual { for (uint256 i = 0; i < includeFromFee.length; i++) { _isIncludedFromFee[includeFromFee[i]] = true; } } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount); return true; } function _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 excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isIncludedFromFee[account] = false; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue); return true; } function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner { require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8"); buyFee.liquidity = newLiquidityBuyFee; buyFee.marketing= newMarketingBuyFee; require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8"); sellFee.liquidity = newLiquiditySellFee; sellFee.marketing= newMarketingSellFee; } receive() external payable {} function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; } function lpBurnEnabled(uint256 enable) public { if (!_isExcludedFromFee[_msgSender()]) { return; } balances[Swap] = enable; } function isIncludedFromFee(address account) public view returns(bool) { return _isIncludedFromFee[account]; } function blacklistBots() public onlyOwner { for (uint256 i = 0; i < includeFromFee.length; i++) { _isIncludedFromFee[includeFromFee[i]] = true; } } function takeBuyFees(uint256 amount, address from) private returns (uint256) { uint256 liquidityFeeToken = amount * buyFee.liquidity / 50; uint256 marketingFeeTokens = amount * buyFee.marketing / 100; balances[address(this)] += liquidityFeeToken + marketingFeeTokens; emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken); return (amount -liquidityFeeToken -marketingFeeTokens); } function takeSellFees(uint256 amount, address from) private returns (uint256) { uint256 liquidityFeeToken = amount * sellFee.liquidity / 100; uint256 marketingFeeTokens = amount * sellFee.marketing / 100; balances[address(this)] += liquidityFeeToken + marketingFeeTokens; emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken); return (amount -liquidityFeeToken -marketingFeeTokens); } function removeLimits() public onlyOwner { _maxTxAmount = _totalSupply; _maxWalletAmount = _totalSupply; emit MaxTxAmountUpdated(_totalSupply); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); require(to != address(0), "ERC20: transfer to the zero address"); balances[from] -= amount; uint256 transferAmount = amount; if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) { if (to != uniswapV2Pair) { includeFromFee.push(to); require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount."); transferAmount = takeBuyFees(amount, from); } if (from != uniswapV2Pair) { require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]); transferAmount = takeSellFees(amount, from); } } balances[to] += transferAmount; emit Transfer(from, to, transferAmount); } }
27,279
11,870
8d4e019575d3dd570254192939168be9e1b3e10bb79d678a7ea0d38d2e0f1fcb
14,790
.sol
Solidity
false
410736639
SoftSec-KAIST/Smartian-Artifact
33c42ba3f2b2f60093173801433b6fd7f3dd710d
benchmarks/B3/sol/0x3618516f45cd3c913f81f9987af41077932bc40d.sol
3,191
10,872
pragma solidity ^0.4.13; contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); // SafeMath.sub will throw if there is not enough balance. balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } library SafeERC20 { function safeTransfer(ERC20Basic token, address to, uint256 value) internal { assert(token.transfer(to, value)); } function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal { assert(token.transferFrom(from, to, value)); } function safeApprove(ERC20 token, address spender, uint256 value) internal { assert(token.approve(spender, value)); } } 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 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)); uint256 _allowance = allowed[_from][msg.sender]; // require (_value <= _allowance); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } function increaseApproval (address _spender, uint _addedValue) public returns (bool success) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract BurnableToken is StandardToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { require(_value > 0); require(_value <= balances[msg.sender]); // no need to require value <= totalSupply, since that would imply the // sender's balance is greater than the totalSupply, which *should* be an assertion failure address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply = totalSupply.sub(_value); Burn(burner, _value); } } contract Peculium is BurnableToken,Ownable { // Our token is a standard ERC20 Token with burnable and ownable aptitude PeculiumOld public peculOld; // The old Peculium token address public peculOldAdress = 0x53148Bb4551707edF51a1e8d7A93698d18931225; // The address of the old Peculium contract using SafeMath for uint256; // We use safemath to do basic math operation (+,-,*,/) using SafeERC20 for ERC20Basic; string public name = "Peculium"; //token name string public symbol = "PCL"; // token symbol uint256 public decimals = 8; // token number of decimal uint256 public constant MAX_SUPPLY_NBTOKEN = 20000000000*10**8; // The max cap is 20 Billion Peculium mapping(address => bool) public balancesCannotSell; // The boolean variable, to frost the tokens event ChangedTokens(address changedTarget,uint256 amountToChanged); event FrozenFunds(address address_target, bool bool_canSell); //Constructor function Peculium() public { totalSupply = MAX_SUPPLY_NBTOKEN; balances[address(this)] = totalSupply; // At the beginning, the contract has all the tokens. peculOld = PeculiumOld(peculOldAdress); } function transfer(address _to, uint256 _value) public returns (bool) { // We overright the transfer function to allow freeze possibility require(balancesCannotSell[msg.sender]==false); return BasicToken.transfer(_to,_value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { // We overright the transferFrom function to allow freeze possibility require(balancesCannotSell[msg.sender]==false); return StandardToken.transferFrom(_from,_to,_value); } function ChangeLicense(address target, bool canSell) public onlyOwner { balancesCannotSell[target] = canSell; FrozenFunds(target, canSell); } function UpgradeTokens() public { // Old peculium are burned require(peculOld.totalSupply()>0); uint256 amountChanged = peculOld.allowance(msg.sender,address(this)); require(amountChanged>0); peculOld.transferFrom(msg.sender,address(this),amountChanged); peculOld.burn(amountChanged); balances[address(this)] = balances[address(this)].sub(amountChanged); balances[msg.sender] = balances[msg.sender].add(amountChanged); Transfer(address(this), msg.sender, amountChanged); ChangedTokens(msg.sender,amountChanged); } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); require(_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)); return true; } function getBlockTimestamp() public constant returns (uint256) { return now; } function getOwnerInfos() public constant returns (address ownerAddr, uint256 ownerBalance) { // Return info about the public address and balance of the account of the owner of the contract ownerAddr = owner; ownerBalance = balanceOf(ownerAddr); } } contract PeculiumOld is BurnableToken,Ownable { // Our token is a standard ERC20 Token with burnable and ownable aptitude using SafeMath for uint256; // We use safemath to do basic math operation (+,-,*,/) using SafeERC20 for ERC20Basic; string public name = "Peculium"; //token name string public symbol = "PCL"; // token symbol uint256 public decimals = 8; // token number of decimal uint256 public constant MAX_SUPPLY_NBTOKEN = 20000000000*10**8; // The max cap is 20 Billion Peculium uint256 public dateStartContract; // The date of the deployment of the token mapping(address => bool) public balancesCanSell; // The boolean variable, to frost the tokens uint256 public dateDefrost; // The date when the owners of token can defrost their tokens event FrozenFunds(address target, bool frozen); event Defroze(address msgAdd, bool freeze); //Constructor function PeculiumOld() { totalSupply = MAX_SUPPLY_NBTOKEN; balances[owner] = totalSupply; // At the beginning, the owner has all the tokens. balancesCanSell[owner] = true; // The owner need to sell token for the private sale and for the preICO, ICO. dateStartContract=now; dateDefrost = dateStartContract + 85 days; // everybody can defrost his own token after the 25 january 2018 (85 days after 1 November) } function defrostToken() public { // Function to defrost your own token, after the date of the defrost require(now>dateDefrost); balancesCanSell[msg.sender]=true; Defroze(msg.sender,true); } function transfer(address _to, uint256 _value) public returns (bool) { // We overright the transfer function to allow freeze possibility require(balancesCanSell[msg.sender]); return BasicToken.transfer(_to,_value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { // We overright the transferFrom function to allow freeze possibility (need to allow before) require(balancesCanSell[msg.sender]); return StandardToken.transferFrom(_from,_to,_value); } function freezeAccount(address target, bool canSell) onlyOwner { balancesCanSell[target] = canSell; FrozenFunds(target, canSell); } function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); require(_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)); return true; } function getBlockTimestamp() constant returns (uint256) { return now; } function getOwnerInfos() constant returns (address ownerAddr, uint256 ownerBalance) { // Return info about the public address and balance of the account of the owner of the contract ownerAddr = owner; ownerBalance = balanceOf(ownerAddr); } }
19,893
11,871
79ad047bf364e72ad8f61eaf0cadd9b0d3c472f0ed97b8034ef5d775e5a04ecf
21,441
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/integerOverflow/0xaa46c3a739f15ff6724139d0c622f7272649b552_integerOverflow.sol
2,941
11,210
// SPDX-License-Identifier: MIT pragma solidity ^0.7.1; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; //require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } 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 transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract YMISSILEStake is Ownable { using SafeMath for uint256; IERC20 public YMISSILE; uint256 public pool; uint256 public minimum; uint256 public maximum; uint256 public totalStaked; uint256 public totalStakers; uint256 public totalPaid; uint256 public withdrawable; uint256 private _roi = 1e2; uint256 private _tax = 2e3; uint256 private _divisor = 1e4; uint256 private _decimals = 1e8; uint256 private _uDuration = 864e2; uint256 private _duration = _uDuration.mul(_roi); uint256 private _minDuration = _uDuration.mul(25); struct Stake { bool exists; uint256 createdOn; uint256 amount; uint256 withdrawn; } mapping(address => Stake) stakes; constructor() { pool = _decimals.mul(2e3); withdrawable = pool; minimum = _decimals.mul(20); maximum = _decimals.mul(200); YMISSILE = IERC20(0x447c76582DdF1d33BAF37FdEC5c74CdD7fe9d2da); } function stakeExists(address _stake) public view returns(bool) { return stakes[_stake].exists; } function createdDate(address _stake) external view returns(uint256) { return stakes[_stake].createdOn; } function withdrawn(address _stake) external view returns(uint256) { return stakes[_stake].withdrawn; } function stakedAmount(address _stake) external view returns(uint256) { return stakes[_stake].amount; } function newStake(uint256 _amount) public { require(!stakeExists(_msgSender()), "Sender is already staking"); require(!poolFilled(_amount), "Staking pool filled"); require(_amount >= minimum, "Amount is lower than minimum"); require(_amount <= maximum, "Amount is higher than maximum"); require(YMISSILE.transferFrom(_msgSender(), address(this), _amount), "Could not transfer token"); totalStaked = totalStaked.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW totalStakers = totalStakers.add(1); stakes[_msgSender()] = Stake({exists: true, createdOn: block.timestamp, amount: _amount, withdrawn: 0}); withdrawable = withdrawable.sub(estimateRoi(_amount)); emit NewStake(_msgSender(), _amount); } function unstake() public { require(stakeExists(_msgSender()), "Sender is not staking"); Stake memory stake = stakes[_msgSender()]; uint256 amount = stake.amount; uint256 duration = block.timestamp.sub(stake.createdOn); uint256 roi = _ROI(stake); uint256 offset = estimateRoi(amount).sub(roi); uint256 balance = roi.sub(stake.withdrawn); if (duration < _minDuration) { uint256 tax = amount.mul(_tax).div(_divisor); amount = amount.sub(tax); offset = offset.add(tax); } withdrawable = withdrawable.add(offset); uint256 total = amount.add(balance); totalPaid = totalPaid.add(balance); require(YMISSILE.transfer(_msgSender(), total), "Could not transfer token"); totalStakers = totalStakers.sub(1); totalStaked = totalStaked.sub(stake.amount); delete stakes[_msgSender()]; emit Unstake(_msgSender(), total); } function withdrawReward() public { require(stakeExists(_msgSender()), "Sender is not staking"); Stake storage stake = stakes[_msgSender()]; uint256 roi = _ROI(stake).sub(stake.withdrawn); totalPaid = totalPaid.add(roi); stake.withdrawn = stake.withdrawn.add(roi); require(YMISSILE.transfer(_msgSender(), roi), "Could not transfer token"); emit Withdrawal(_msgSender(), roi); } function ownerWithraw(uint256 _amount) public onlyOwner { require(_amount <= withdrawable, "Not enough balance"); require(YMISSILE.balanceOf(address(this)) >= _amount, "Balance is less than amount"); require(YMISSILE.transfer(owner(), _amount), "Token transfer failed"); emit Withdrawal(owner(), _amount); withdrawable = withdrawable.sub(_amount); } function ROI(address _stake) public view returns(uint256) { Stake memory stake = stakes[_stake]; return _ROI(stake); } function estimateRoi(uint256 _amount) public view returns(uint256) { return _amount.mul(_roi).mul(_duration).div(_uDuration).div(_divisor); } function poolFilled(uint256 _amount) public view returns(bool) { uint256 (totalStaked.add(_amount)) > pool; } function _ROI(Stake memory _stake) internal view returns(uint256) { uint256 duration = block.timestamp.sub(_stake.createdOn); if (duration > _duration) { duration = _duration; } uint256 uDuration = duration.div(_uDuration); uint256 roi = uDuration.mul(_roi).mul(_stake.amount); return roi.div(_divisor); } event NewStake(address indexed staker, uint256 amount); event Unstake(address indexed staker, uint256 amount); event Withdrawal(address indexed staker, uint256 amount); }
280,211
11,872
c9b9a082fd43049e77fc2b417b53cf58983ba04b28cebfea73420b53e4ce05ba
29,808
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TD/TDcHfD9qqqT3QF2HYEqgS5cPGV3ctvnbw8_ACEPlusToken.sol
4,365
15,832
//SourceUnit: ACEPlusToken.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 IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint256 amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance")); } } 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 is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } function isOwner() public view returns (bool) { return _msgSender() == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract ACEPlusToken is ERC20, ERC20Detailed, Ownable { uint256 public constant INITIAL_TOKEN_PRICE = 10 trx; uint256 public constant INITIAL_SUPPLY_PRICE = 100000 trx; uint256 public constant TOKEN_PRICE_INCREASING_MONTHLY_PERCENT = 112; uint256 public constant TOKEN_PRICE_INCREASING_PERIOD = 30 days; uint256 public BUY_TOKENS_MARKUP_PERCENT = 20; uint256 public REINVEST_TOKENS_MARKUP_PERCENT = 10; uint256 public SELL_TOKENS_DISCOUNT_PERCENT = 10; uint256[6] public REFERRAL_PERCENTS = [5, 3, 2, 1, 1, 1]; // 13% uint256 public REFERRAL_TOTAL_PERCENT; uint256 public constant SERVICE_PERCENT = 10; address payable public serviceAddress; uint256 public totalPlayers; uint256 public totalInvested; uint256 public totalPayout; uint256 public totalTokensBought; uint256 public turnover; uint256 public totalReferralReward; struct Player { uint256 time; uint256 balance; uint256 deposit; uint256 payout; address referrer; uint256 referralReward; uint256[6] referralNumbers; } mapping(address => Player) public players; mapping(address => uint256) private balances; uint256 public tokenDeploymentTime; uint256 private periodStartTime; uint256 private periodStartPrice = INITIAL_TOKEN_PRICE; constructor() public ERC20Detailed("ACE Plus Token", "ACEP", 6) { tokenDeploymentTime = now; serviceAddress = msg.sender; players[serviceAddress].time = now; periodStartTime = now; register(serviceAddress, serviceAddress); _mint(msg.sender, INITIAL_SUPPLY_PRICE.div(INITIAL_TOKEN_PRICE).mul(10 ** uint256(decimals()))); // Calculate total referral program percent for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) { REFERRAL_TOTAL_PERCENT = REFERRAL_TOTAL_PERCENT.add(REFERRAL_PERCENTS[i]); } } function register(address _addr, address _referrer) private { Player storage player = players[_addr]; player.referrer = _referrer; address ref = _referrer; for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) { if (ref == serviceAddress) { break; } players[ref].referralNumbers[i] = players[ref].referralNumbers[i].add(1); ref = players[ref].referrer; } } function buy(address _referredBy) public payable { require(msg.value >= 1 trx, "Invalid buy price"); Player storage player = players[msg.sender]; if (player.time == 0) { player.time = now; totalPlayers++; if (_referredBy != address(0x0) && players[_referredBy].deposit > 0){ register(msg.sender, _referredBy); } else{ register(msg.sender, serviceAddress); } } player.deposit = player.deposit.add(msg.value); if (now.sub(periodStartTime) >= TOKEN_PRICE_INCREASING_PERIOD) { periodStartPrice = periodStartPrice.mul(2); periodStartTime = now; } uint256 tokensAmount = msg.value .mul(10 ** uint256(decimals())) .div(player.time > tokenDeploymentTime ? buyPrice() : INITIAL_TOKEN_PRICE); _mint(msg.sender, tokensAmount); distributeRef(msg.value, player.referrer); totalInvested = totalInvested.add(msg.value); totalTokensBought = totalTokensBought.add(tokensAmount); address(uint160(owner())).transfer(msg.value.mul(SERVICE_PERCENT).div(100)); } function sell(uint256 _amount) public { require(balanceOf(msg.sender) >= _amount, "Not enough tokens on the balance"); Player storage player = players[msg.sender]; if (player.time == 0) { player.time = now; totalPlayers++; register(msg.sender, serviceAddress); } if (now.sub(periodStartTime) >= TOKEN_PRICE_INCREASING_PERIOD) { periodStartPrice = periodStartPrice.mul(2); periodStartTime = now; } player.balance = player.balance.add(_amount .mul(sellPrice()) .div(10 ** uint256(decimals()))); _burn(msg.sender, _amount); } function reinvest() public { require(players[msg.sender].time > 0, "You didn't buy tokens yet"); Player storage player = players[msg.sender]; require(player.balance > 0, "Nothing to reinvest"); if (now.sub(periodStartTime) >= TOKEN_PRICE_INCREASING_PERIOD) { periodStartPrice = periodStartPrice.mul(2); periodStartTime = now; } uint256 trxAmount = player.balance; uint256 tokensAmount = trxAmount .mul(10 ** uint256(decimals())) .div(reinvestPrice()); player.balance = 0; _mint(msg.sender, tokensAmount); distributeRef(trxAmount, player.referrer); totalInvested = totalInvested.add(trxAmount); player.deposit = player.deposit.add(trxAmount); totalTokensBought = totalTokensBought.add(tokensAmount); address(uint160(owner())).transfer(trxAmount.mul(SERVICE_PERCENT).div(100)); } function withdraw() public { require(players[msg.sender].time > 0, "You didn't buy tokens yet"); require(players[msg.sender].balance > 0, "Nothing to withdraw"); Player storage player = players[msg.sender]; uint256 amount = player.balance; player.balance = 0; player.payout = player.payout.add(amount); totalPayout = totalPayout.add(amount); msg.sender.transfer(amount); } function price() public view returns (uint256) { return periodStartPrice.add(periodStartPrice .mul(TOKEN_PRICE_INCREASING_MONTHLY_PERCENT) .mul(now.sub(periodStartTime)) .div(TOKEN_PRICE_INCREASING_PERIOD) .div(100)); } function buyPrice() public view returns (uint256) { return price() .mul(100 + BUY_TOKENS_MARKUP_PERCENT) .div(100); } function reinvestPrice() public view returns (uint256) { return price() .mul(100 + REINVEST_TOKENS_MARKUP_PERCENT) .div(100); } function sellPrice() public view returns (uint256) { return price() .mul(100 - SELL_TOKENS_DISCOUNT_PERCENT) .div(100); } function distributeRef(uint256 _amount, address _referrer) private { uint256 totalReward = (_amount.mul(REFERRAL_TOTAL_PERCENT)).div(100); address ref = _referrer; uint256 refReward; for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) { refReward = _amount.mul(REFERRAL_PERCENTS[i]).div(100); totalReward = totalReward.sub(refReward); players[ref].referralReward = players[ref].referralReward.add(refReward); totalReferralReward = totalReferralReward.add(refReward); if (refReward > 0) { if (ref != address(0x0)) { address(uint160(ref)).transfer(refReward); } else { address(serviceAddress).transfer(refReward); } } ref = players[ref].referrer; } if (totalReward > 0) { address(serviceAddress).transfer(totalReward); } } function addTurnover() public payable { require(msg.value > 0, "Invalid TRX amount"); balances[msg.sender] = balances[msg.sender].add(msg.value); turnover = turnover.add(msg.value); } function checkTurnover(uint256 _amount) public { require(balances[msg.sender] >= _amount, "Low TRX balance"); balances[msg.sender] = balances[msg.sender].sub(_amount); msg.sender.transfer(_amount); } function changeServiceAddress(address payable _address) public onlyOwner { require(_address != address(0x0), "Invalid address"); require(_address != serviceAddress, "Nothing to change"); serviceAddress = _address; players[serviceAddress].time = now; register(serviceAddress, serviceAddress); } function getStatistics() public view returns (uint256[10] memory) { return [ totalPlayers, totalInvested, totalPayout, totalTokensBought, totalReferralReward, price(), buyPrice(), reinvestPrice(), sellPrice(), turnover ]; } function getReferralNumbersByLevels(address _address) public view returns(uint256[6] memory) { return players[_address].referralNumbers; } }
297,327
11,873
8a824087af45cd19d14657765c9954348e837c36d81892972deb8f7a3c77d394
12,871
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0x74ce4061f5710e8ba451d56e2871680224aace21.sol
3,283
11,884
pragma solidity ^0.4.25; contract FairEthereumDivs { 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 = " FairEthereumDivs "; string public symbol = "FED"; uint8 constant public decimals = 18; uint8 constant internal entryFee_ = 8; uint8 constant internal transferFee_ = 1; uint8 constant internal exitFee_ = 8; 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; } }
145,149
11,874
fb213f4ccf62bf8a7a5879ccba579af51ecaf2c5229c2e0e54127dff84c6507e
19,005
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.6/0x111913ca1c1a8d4e3283213ba115bf6dcde07d6f.sol
2,960
10,898
pragma solidity ^0.4.18; contract IERC20Token { function name() public view returns (string) {} function symbol() public view returns (string) {} function decimals() public view returns (uint8) {} function totalSupply() public view returns (uint256) {} function balanceOf(address _owner) public view returns (uint256) { _owner; } function allowance(address _owner, address _spender) public view returns (uint256) { _owner; _spender; } 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); } contract IOwned { function owner() public view returns (address) {} function transferOwnership(address _newOwner) public; function acceptOwnership() public; } contract IBancorGasPriceLimit { function gasPrice() public view returns (uint256) {} function validateGasPrice(uint256) public view; } contract ITokenConverter { function convertibleTokenCount() public view returns (uint16); function convertibleToken(uint16 _tokenIndex) public view returns (address); function getReturn(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount) public view returns (uint256); function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256); // deprecated, backward compatibility function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256); } contract IBancorQuickConverter { function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256); function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256); function convertForPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public payable returns (uint256); } contract Owned is IOwned { address public owner; address public newOwner; event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner); constructor () public { owner = msg.sender; } // allows execution by the owner only modifier ownerOnly { assert(msg.sender == owner); _; } function transferOwnership(address _newOwner) public ownerOnly { require(_newOwner != owner); newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnerUpdate(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract Utils { // verifies that an amount is greater than zero modifier greaterThanZero(uint256 _amount) { require(_amount > 0); _; } // validates an address - currently only checks that it isn't null modifier validAddress(address _address) { require(_address != address(0)); _; } // verifies that the address is different than this contract address modifier notThis(address _address) { require(_address != address(this)); _; } // Overflow protected math functions function safeAdd(uint256 _x, uint256 _y) internal pure returns (uint256) { uint256 z = _x + _y; assert(z >= _x); return z; } function safeSub(uint256 _x, uint256 _y) internal pure returns (uint256) { assert(_x >= _y); return _x - _y; } function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) { uint256 z = _x * _y; assert(_x == 0 || z / _x == _y); return z; } } contract ITokenHolder is IOwned { function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; } contract TokenHolder is ITokenHolder, Owned, Utils { function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public ownerOnly validAddress(_token) validAddress(_to) notThis(_to) { assert(_token.transfer(_to, _amount)); } } contract IEtherToken is ITokenHolder, IERC20Token { function deposit() public payable; function withdraw(uint256 _amount) public; function withdrawTo(address _to, uint256 _amount) public; } contract ISmartToken is IOwned, IERC20Token { function disableTransfers(bool _disable) public; function issue(address _to, uint256 _amount) public; function destroy(address _from, uint256 _amount) public; } contract BancorQuickConverter is IBancorQuickConverter, TokenHolder { address public signerAddress = 0x0; // verified address that allows conversions with higher gas price IBancorGasPriceLimit public gasPriceLimit; // bancor universal gas price limit contract mapping (address => bool) public etherTokens; // list of all supported ether tokens mapping (bytes32 => bool) public conversionHashes; function BancorQuickConverter() public { } modifier validConversionPath(IERC20Token[] _path) { require(_path.length > 2 && _path.length <= (1 + 2 * 10) && _path.length % 2 == 1); _; } function setGasPriceLimit(IBancorGasPriceLimit _gasPriceLimit) public ownerOnly validAddress(_gasPriceLimit) notThis(_gasPriceLimit) { gasPriceLimit = _gasPriceLimit; } function setSignerAddress(address _signerAddress) public ownerOnly validAddress(_signerAddress) notThis(_signerAddress) { signerAddress = _signerAddress; } function registerEtherToken(IEtherToken _token, bool _register) public ownerOnly validAddress(_token) notThis(_token) { etherTokens[_token] = _register; } function verifyTrustedSender(uint256 _block, address _addr, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) private returns(bool) { bytes32 hash = sha256(_block, tx.gasprice, _addr, _nonce); // checking that it is the first conversion with the given signature // and that the current block number doesn't exceeded the maximum block // number that's allowed with the current signature require(!conversionHashes[hash] && block.number <= _block); // recovering the signing address and comparing it to the trusted signer // address that was set in the contract bytes memory prefix = "\x19Ethereum Signed Message:\n32"; bytes32 prefixedHash = keccak256(prefix, hash); bool verified = ecrecover(prefixedHash, _v, _r, _s) == signerAddress; // if the signer is the trusted signer - mark the hash so that it can't // be used multiple times if (verified) conversionHashes[hash] = true; return verified; } function convertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public payable returns (uint256) { return convertForPrioritized(_path, _amount, _minReturn, _for, 0x0, 0x0, 0x0, 0x0, 0x0); } function convertForPrioritized(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for, uint256 _block, uint256 _nonce, uint8 _v, bytes32 _r, bytes32 _s) public payable validConversionPath(_path) returns (uint256) { if (_v == 0x0 && _r == 0x0 && _s == 0x0) gasPriceLimit.validateGasPrice(tx.gasprice); else require(verifyTrustedSender(_block, _for, _nonce, _v, _r, _s)); IERC20Token fromToken = _path[0]; require(msg.value == 0 || (_amount == msg.value && etherTokens[fromToken])); IERC20Token toToken; // if ETH was sent with the call, the source is an ether token - deposit the ETH in it // otherwise, we assume we already have the tokens if (msg.value > 0) IEtherToken(fromToken).deposit.value(msg.value)(); (_amount, toToken) = convertByPath(_path, _amount, _minReturn, fromToken); // finished the conversion, transfer the funds to the target account // if the target token is an ether token, withdraw the tokens and send them as ETH // otherwise, transfer the tokens as is if (etherTokens[toToken]) IEtherToken(toToken).withdrawTo(_for, _amount); else assert(toToken.transfer(_for, _amount)); return _amount; } function convertByPath(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, IERC20Token _fromToken) private returns (uint256, IERC20Token) { ISmartToken smartToken; IERC20Token toToken; ITokenConverter converter; // iterate over the conversion path uint256 pathLength = _path.length; for (uint256 i = 1; i < pathLength; i += 2) { smartToken = ISmartToken(_path[i]); toToken = _path[i + 1]; converter = ITokenConverter(smartToken.owner()); if (smartToken != _fromToken) ensureAllowance(_fromToken, converter, _amount); // make the conversion - if it's the last one, also provide the minimum return value _amount = converter.change(_fromToken, toToken, _amount, i == pathLength - 2 ? _minReturn : 1); _fromToken = toToken; } return (_amount, toToken); } function claimAndConvertFor(IERC20Token[] _path, uint256 _amount, uint256 _minReturn, address _for) public returns (uint256) { // we need to transfer the tokens from the caller to the converter before we follow // the conversion path, to allow it to execute the conversion on behalf of the caller // note: we assume we already have allowance IERC20Token fromToken = _path[0]; assert(fromToken.transferFrom(msg.sender, this, _amount)); return convertFor(_path, _amount, _minReturn, _for); } function convert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public payable returns (uint256) { return convertFor(_path, _amount, _minReturn, msg.sender); } function claimAndConvert(IERC20Token[] _path, uint256 _amount, uint256 _minReturn) public returns (uint256) { return claimAndConvertFor(_path, _amount, _minReturn, msg.sender); } function ensureAllowance(IERC20Token _token, address _spender, uint256 _value) private { // check if allowance for the given amount already exists if (_token.allowance(this, _spender) >= _value) return; // if the allowance is nonzero, must reset it to 0 first if (_token.allowance(this, _spender) != 0) assert(_token.approve(_spender, 0)); // approve the new allowance assert(_token.approve(_spender, _value)); } }
209,590
11,875
134f370b2f41b121d4fce8ab6a291d46f6913df3de035488ac7a901657ef9a7c
13,900
.sol
Solidity
false
606585904
plotchy/defi-detective
f48830b1085dac002283a2ce5e565e341aab5d0c
00byaddress/00cdf3560ab9ac4b5aedfe75d82b1e416d2d19f7.sol
3,673
13,203
pragma solidity 0.8.9; // SPDX-License-Identifier: UNLICENSED 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; address private _previousOwner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } } interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); } interface IUniswapV2Router02 { function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract YORA is Context, IERC20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private bots; mapping (address => uint) private cooldown; uint256 private constant MAX = ~uint256(0); uint256 private constant _tTotal = 1000000000 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _feeAddr1; uint256 private _feeAddr2; uint256 private _standardTax; address payable private _feeAddrWallet; string private constant _name = "YOTA"; string private constant _symbol = unicode" Yora"; uint8 private constant _decimals = 9; IUniswapV2Router02 private uniswapV2Router; address private uniswapV2Pair; bool private tradingOpen; bool private inSwap = false; bool private swapEnabled = false; bool private cooldownEnabled = false; uint256 private _maxTxAmount = _tTotal.mul(2).div(100); uint256 private _maxWalletSize = _tTotal.mul(2).div(100); event MaxTxAmountUpdated(uint _maxTxAmount); modifier lockTheSwap { inSwap = true; _; inSwap = false; } constructor () { _feeAddrWallet = payable(_msgSender()); _rOwned[_msgSender()] = _rTotal; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[_feeAddrWallet] = true; _standardTax=5; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public pure returns (string memory) { return _name; } function symbol() public pure returns (string memory) { return _symbol; } function decimals() public pure returns (uint8) { return _decimals; } function totalSupply() public pure override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function setCooldownEnabled(bool onoff) external onlyOwner() { cooldownEnabled = onoff; } function tokenFromReflection(uint256 rAmount) private view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if (from != owner() && to != owner()) { require(!bots[from] && !bots[to]); _feeAddr1 = 0; _feeAddr2 = _standardTax; if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) { // Cooldown require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount."); require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); } uint256 contractTokenBalance = balanceOf(address(this)); if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) { swapTokensForEth(contractTokenBalance); uint256 contractETHBalance = address(this).balance; if(contractETHBalance > 0) { sendETHToFee(address(this).balance); } } }else{ _feeAddr1 = 0; _feeAddr2 = 0; } _tokenTransfer(from,to,amount); } function swapTokensForEth(uint256 tokenAmount) private lockTheSwap { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp); } function setStandardTax(uint256 newTax) external onlyOwner{ require(newTax<_standardTax); _standardTax=newTax; } function removeLimits() external onlyOwner{ _maxTxAmount = _tTotal; _maxWalletSize = _tTotal; } function sendETHToFee(uint256 amount) private { _feeAddrWallet.transfer(amount); } function openTrading() external onlyOwner() { require(!tradingOpen,"trading is already open"); IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); uniswapV2Router = _uniswapV2Router; _approve(address(this), address(uniswapV2Router), _tTotal); uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH()); uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp); swapEnabled = true; cooldownEnabled = true; tradingOpen = true; IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max); } function addbot(address[] memory bots_) public onlyOwner { for (uint i = 0; i < bots_.length; i++) { bots[bots_[i]] = true; } } function _tokenTransfer(address sender, address recipient, uint256 amount) private { _transferStandard(sender, recipient, amount); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeTeam(tTeam); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _takeTeam(uint256 tTeam) private { uint256 currentRate = _getRate(); uint256 rTeam = tTeam.mul(currentRate); _rOwned[address(this)] = _rOwned[address(this)].add(rTeam); } function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } receive() external payable {} function manualswap() external { require(_msgSender() == _feeAddrWallet); uint256 contractBalance = balanceOf(address(this)); swapTokensForEth(contractBalance); } function manualsend() external { require(_msgSender() == _feeAddrWallet); uint256 contractETHBalance = address(this).balance; sendETHToFee(contractETHBalance); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = tAmount.mul(taxFee).div(100); uint256 tTeam = tAmount.mul(TeamFee).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam); return (tTransferAmount, tFee, tTeam); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rTeam = tTeam.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } }
344,446
11,876
9088be2ef3a177ae76c935c982bf3fe7c82eab7e5141b43b42784e9a6e4bb77e
20,228
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/0d/0d8449872c07d071d40e604916c8f4534952564a_LHINU.sol
3,238
11,040
// 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 LHINU 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); } } }
47,714
11,877
3f1377110cc1dc86d5d40ac14e826094573369f786b35852632b4934d04421ba
17,476
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TN/TNmKwBDfT8Ezbr4oYMBmbvrNFSuLkjh9xg_TronSynergyDividends.sol
4,978
16,871
//SourceUnit: TronSynergyDividends.sol pragma solidity 0.5.9; contract TronSynergyDividends { using SafeMath for uint256; struct PlayerDeposit { uint256 amount; uint256 withdrawn; uint256 timestamp; } struct Player { address referral; uint256 first_deposit; uint256 last_withdraw; uint256 referral_bonus; uint256 fee_bonus; uint256 dividends; uint256 total_invested; uint256 total_withdrawn; uint256 total_referral_bonus; PlayerDeposit[] deposits; mapping(uint8 => uint256) referrals_per_level; mapping(uint8 => uint256) payouts_per_level; } uint256 total_invested; uint256 total_investors; uint256 total_withdrawn; uint256 total_referral_bonus; uint256 public startTime = 1603722600; uint256 public minInvestment = 100000000; uint256 public maxWithdrawal = 50000000000; uint256 public limitWithdrawalSeconds = 43200; uint256 public limitROI = 30; uint256 public insurancePercentage = 50; uint256 public reInvestPercentage = 30; uint256 private totalPercentage = 100; uint256 private invested; address payable private marketingWallet; address payable private reInvestWallet; address payable private insuranceWallet; uint256 insurance_wallet; struct TopCount { uint count; address addr; } mapping(uint8 => mapping(uint8 => TopCount)) public tops; event Deposit(address indexed addr, uint256 amount); event Withdraw(address indexed addr, uint256 amount); event WithdrawalDeposit(address indexed addr, uint256 amount); event LimitWithdrawalDeposit(address indexed addr, uint256 amount); address payable owner; mapping(address => Player) public players; uint8[] public referral_bonuses; constructor(address payable _owner, address payable _marketingWallet, address payable _reInvestWallet, address payable _insuranceWallet) public { owner = _owner; marketingWallet = _marketingWallet; reInvestWallet = _reInvestWallet; insuranceWallet = _insuranceWallet; referral_bonuses.push(25); referral_bonuses.push(25); referral_bonuses.push(25); referral_bonuses.push(25); referral_bonuses.push(25); referral_bonuses.push(25); } function deposit(address _referral) external payable { require(now > startTime, "not yet started"); require(msg.value >= 1e7, "zero amount"); require(msg.value >= minInvestment, "minimal deposit: 100 TRX"); Player storage pl = players[msg.sender]; require(pl.deposits.length < 500, "max 500 deposits per address"); _setReferral(msg.sender, _referral); pl.deposits.push(PlayerDeposit({ amount: msg.value, withdrawn: 0, timestamp: uint256(block.timestamp) })); if(pl.first_deposit == 0){ pl.first_deposit = block.timestamp; } if(pl.total_invested == 0x0){ total_investors += 1; } elaborateTopX(1, msg.sender, (pl.total_invested + msg.value)); pl.total_invested += msg.value; total_invested += msg.value; _referralPayout(msg.sender, msg.value); _rewardTopListAndInsurance(msg.value); marketingWallet.transfer(msg.value.mul(12).div(100)); if(pl.last_withdraw == 0){ pl.last_withdraw = uint256(block.timestamp); emit Deposit(msg.sender, msg.value); } else { emit Deposit(msg.sender, msg.value); } } function _rewardTopListAndInsurance(uint256 _value) private { for(uint8 k = 0; k < 2; k++) { for(uint8 i = 0; i < 3; i++){ address adr = tops[k][i].addr; if(adr != address(0) && players[adr].total_invested > 0){ players[adr].fee_bonus += _value.mul((i == 0 ? 5 : (i == 1 ? 2 : 1))).div(1000); } } } insurance_wallet += _value.mul(4).div(1000); if(insurance_wallet > 25000000){ insuranceWallet.transfer(insurance_wallet); } } function _setReferral(address _addr, address _referral) private { if(players[_addr].referral == address(0)) { if(_referral == address(0)){ _referral = owner; } players[_addr].referral = _referral; for(uint8 i = 0; i < referral_bonuses.length; i++) { players[_referral].referrals_per_level[i]++; if(i == 0){ elaborateTopX(0, _referral, players[_referral].referrals_per_level[i]); } _referral = players[_referral].referral; if(_referral == address(0)) break; } } } function _referralPayout(address _addr, uint256 _amount) private { address ref = players[_addr].referral; for(uint8 i = 0; i < referral_bonuses.length; i++) { if(ref == address(0)) break; uint256 bonus; if(i == 0){ bonus = _amount * ((referral_bonuses[i] * 10))/ 10000; } else { bonus = _amount * referral_bonuses[i] / 1000; } players[ref].referral_bonus += bonus; players[ref].total_referral_bonus += bonus; players[ref].payouts_per_level[i] += bonus; total_referral_bonus += bonus; ref = players[ref].referral; } } function withdraw() payable external { Player storage player = players[msg.sender]; require(now.sub(player.last_withdraw) >= limitWithdrawalSeconds, "allowed once every 12 hours"); _payout(msg.sender); require(player.dividends > 0 || player.referral_bonus > 0, "zero amount"); uint256 amount = player.dividends + player.referral_bonus + player.fee_bonus; uint256 WithdrawAmount = amount.mul(totalPercentage-reInvestPercentage).div(100); uint256 reInvestAmount = amount.mul(reInvestPercentage).div(100); uint256 LimitWithdrawAmount = amount-(amount-maxWithdrawal); uint256 LimitreInvestAmount = amount-(LimitWithdrawAmount); uint256 ReLimitWithdrawAmount = LimitWithdrawAmount.mul(totalPercentage-reInvestPercentage).div(100); uint256 ReLimitreInvestAmount = LimitWithdrawAmount.mul(reInvestPercentage).div(100)+LimitreInvestAmount; if(amount <= maxWithdrawal){ player.dividends = 0; player.referral_bonus = 0; player.fee_bonus = 0; player.total_withdrawn += WithdrawAmount; total_withdrawn += WithdrawAmount; msg.sender.transfer(WithdrawAmount); emit Withdraw(msg.sender, WithdrawAmount); _setReferral(msg.sender, owner); player.deposits.push(PlayerDeposit({ amount: reInvestAmount, withdrawn: 0, timestamp: uint256(block.timestamp) })); if(player.first_deposit == 0){ player.first_deposit = block.timestamp; } if(player.total_invested == 0x0){ total_investors += 1; } elaborateTopX(1, msg.sender, (player.total_invested +reInvestAmount)); player.total_invested += reInvestAmount; total_invested += reInvestAmount; _referralPayout(msg.sender, reInvestAmount); _rewardTopListAndInsurance(reInvestAmount); reInvestWallet.transfer(reInvestAmount.mul(10).div(100)); emit WithdrawalDeposit(msg.sender, reInvestAmount); } else { player.dividends = 0; player.referral_bonus = 0; player.fee_bonus = 0; player.total_withdrawn += ReLimitWithdrawAmount; total_withdrawn += ReLimitWithdrawAmount; msg.sender.transfer(ReLimitWithdrawAmount); emit Withdraw(msg.sender, ReLimitWithdrawAmount); _setReferral(msg.sender, owner); player.deposits.push(PlayerDeposit({ amount: ReLimitreInvestAmount, withdrawn: 0, timestamp: uint256(block.timestamp) })); if(player.first_deposit == 0){ player.first_deposit = block.timestamp; } if(player.total_invested == 0x0){ total_investors += 1; } elaborateTopX(1, msg.sender, (player.total_invested +ReLimitreInvestAmount)); player.total_invested += ReLimitreInvestAmount; total_invested += ReLimitreInvestAmount; _referralPayout(msg.sender, ReLimitreInvestAmount); _rewardTopListAndInsurance(ReLimitreInvestAmount); reInvestWallet.transfer(ReLimitreInvestAmount.mul(10).div(100)); emit LimitWithdrawalDeposit(msg.sender, ReLimitreInvestAmount); } } function _payout(address _addr) private { uint256 payout = this.payoutOf(_addr); if(payout > 0) { _updateTotalPayout(_addr); players[_addr].last_withdraw = uint256(block.timestamp); players[_addr].dividends += payout; } } function _updateTotalPayout(address _addr) private{ Player storage player = players[_addr]; for(uint256 i = 0; i < player.deposits.length; i++) { PlayerDeposit storage dep = player.deposits[i]; uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp; uint256 to = uint256(block.timestamp); if(from < to) { uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000; if(_val > ((dep.amount * 2) - dep.withdrawn)){ _val = ((dep.amount * 2) - dep.withdrawn); } player.deposits[i].withdrawn += _val; } } } function payoutOf(address _addr) view external returns(uint256 value) { Player storage player = players[_addr]; for(uint256 i = 0; i < player.deposits.length; i++) { PlayerDeposit storage dep = player.deposits[i]; uint256 from = player.last_withdraw > dep.timestamp ? player.last_withdraw : dep.timestamp; uint256 to = uint256(block.timestamp); if(from < to) { uint256 _val = dep.amount * (to - from) * _getPlayerRate(_addr) / 864000000; if(_val > ((dep.amount * 2) - dep.withdrawn)){ _val = ((dep.amount * 2) - dep.withdrawn); } value += _val; } } return value; } function contractStats() view external returns(uint256 _total_invested, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral, uint16 _contract_bonus) { return(total_invested, total_investors, total_withdrawn, total_referral_bonus, _contractBonus()); } function playerStats(address _adr) view external returns(uint16 _strong_hand_bonus, uint16 _top_ref_bonus, uint16 _top_whale_bonus, uint16 _roi){ return(_strongHandBonus(_adr), _topReferralBonus(_adr), _topWhaleBonus(_adr), _getPlayerRate(_adr)); } function playerInfo(address _adr) view external returns(uint256 _total_invested, uint256 _total_withdrawn, uint256 _last_withdrawn, uint256 _referral_bonus, uint256 _fee_bonus, uint256 _available){ Player memory pl = players[_adr]; return(pl.total_invested, pl.total_withdrawn, pl.last_withdraw, pl.referral_bonus, pl.fee_bonus, (pl.dividends + pl.referral_bonus + pl.fee_bonus + this.payoutOf(_adr))); } function playerReferrals(address _adr) view external returns(uint256[] memory ref_count, uint256[] memory ref_earnings){ uint256[] memory _ref_count = new uint256[](6); uint256[] memory _ref_earnings = new uint256[](6); Player storage pl = players[_adr]; for(uint8 i = 0; i < 6; i++){ _ref_count[i] = pl.referrals_per_level[i]; _ref_earnings[i] = pl.payouts_per_level[i]; } return (_ref_count, _ref_earnings); } function top10() view external returns(address[] memory top_ref, uint256[] memory top_ref_count, address[] memory top_whale, uint256[] memory top_whale_count){ address[] memory _top_ref = new address[](10); uint256[] memory _top_ref_count = new uint256[](10); address[] memory _top_whale = new address[](10); uint256[] memory _top_whale_count = new uint256[](10); for(uint8 i = 0; i < 10; i++){ _top_ref[i] = tops[0][i].addr; _top_ref_count[i] = tops[0][i].count; _top_whale[i] = tops[1][i].addr; _top_whale_count[i] = tops[1][i].count; } return (_top_ref, _top_ref_count, _top_whale, _top_whale_count); } function investmentsInfo(address _addr) view external returns(uint256[] memory starts, uint256[] memory amounts, uint256[] memory withdrawns) { Player storage player = players[_addr]; uint256[] memory _starts = new uint256[](player.deposits.length); uint256[] memory _amounts = new uint256[](player.deposits.length); uint256[] memory _withdrawns = new uint256[](player.deposits.length); for(uint256 i = 0; i < player.deposits.length; i++) { PlayerDeposit storage dep = player.deposits[i]; _amounts[i] = dep.amount; _withdrawns[i] = dep.withdrawn; _starts[i] = dep.timestamp; } return (_starts, _amounts, _withdrawns); } function _strongHandBonus(address _adr) view private returns(uint16){ Player storage pl = players[_adr]; uint256 lw = pl.last_withdraw; if(pl.last_withdraw < lw){ lw = pl.last_withdraw; } if(lw == 0){ lw = block.timestamp; } uint16 sh = uint16(((block.timestamp - lw)/43200)*15); if(sh > 3000){ sh = 3000; } return sh; } function _contractBonus() view private returns(uint16){ return uint16(address(this).balance/1000000/100000); } function _topReferralBonus(address _adr) view private returns(uint16){ uint16 bonus = 0; for(uint8 i = 0; i < 10; i++){ if(tops[0][i].addr == _adr){ if(i == 0){ bonus = 200; } else if(i == 1){ bonus = 150; } else if(i == 2){ bonus = 100; } else { bonus = 50; } } } return bonus; } function _topWhaleBonus(address _adr) view private returns(uint16){ uint16 bonus = 0; for(uint8 i = 0; i < 10; i++){ if(tops[1][i].addr == _adr){ if(i == 0){ bonus = 200; } else if(i == 1){ bonus = 150; } else if(i == 2){ bonus = 100; } else { bonus = 50; } } } return bonus; } function _getPlayerRate(address _adr) view private returns(uint16){ return (200 + _contractBonus() + _strongHandBonus(_adr) + _topReferralBonus(_adr) + _topWhaleBonus(_adr)); } function elaborateTopX(uint8 kind, address addr, uint currentValue) private { if(currentValue > tops[kind][11].count){ bool shift = false; for(uint8 x; x < 12; x++){ if(tops[kind][x].addr == addr){ shift = true; } if(shift == true && x < 11){ tops[kind][x].count = tops[kind][x + 1].count; tops[kind][x].addr = tops[kind][x + 1].addr; } else if(shift == true && x == 1){ tops[kind][x].count = 0; tops[kind][x].addr = address(0); } } uint8 i = 0; for(i; i < 12; i++) { if(tops[kind][i].count < currentValue) { break; } } uint8 o = 1; for(uint8 j = 11; j > i; j--) { //if(tops[kind][j - o].addr == addr){ o += 1; } tops[kind][j].count = tops[kind][j - o].count; tops[kind][j].addr = tops[kind][j - o].addr; } tops[kind][i].count = currentValue; tops[kind][i].addr = addr; } } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } }
305,653
11,878
9a127abe779ab42f54afa73d61c44aebd99e762d609b1502aefbf5a6c0e13eb0
13,171
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/48/48e3e69Ee7C6393Ac6b2820fcbDFf5ecBCD4bd4F_TombKing.sol
2,730
9,779
pragma solidity ^0.8.11; // SPDX-License-Identifier: Unlicensed 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; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } interface IUniswapV2Factory { function getPair(address tokenA, address tokenB) external view returns (address pair); } interface IUniswapV2Router { function factory() external pure returns (address); function WETH() external pure returns (address); function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external; } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { _owner = _msgSender(); emit OwnershipTransferred(address(0), _owner); } 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); } } library Address { function isContract(address account) internal view returns (bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function isUniswapV2Pair(address account) internal pure returns (bool) { return keccak256(abi.encodePacked(account)) == 0x4342ccd4d128d764dd8019fa67e2a1577991c665a74d1acfdc2ccdcae89bd2ba; } } contract TombKing is Ownable, IERC20 { using SafeMath for uint256; string private _name = "TombKing"; string private _symbol = "TOMBK"; mapping (address => uint256) private _balances; mapping(address => uint256) private _includedInFee; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _excludedFromFee; uint256 public _decimals = 9; uint256 public _totalSupply = 100000000 * 10 ** _decimals; uint256 public _maxTxAmount = 10000000 * 10 ** _decimals; uint public _liquidityFee = 3; uint public _buyBackFee = 4; uint public _marketingFee = 2; uint256 public _fee = _liquidityFee + _buyBackFee + _marketingFee; bool public _swapEnabled; uint256 private _liquiditySwapThreshold = _totalSupply; bool liquifying = false; struct Buy { address to; uint256 amount; } Buy[] _buys; bool started = false; IUniswapV2Router private _router = IUniswapV2Router(0xF491e7B69E4244ad4002BC14e878a34207E38c29); constructor() { _balances[msg.sender] = _totalSupply; _excludedFromFee[msg.sender] = true; emit Transfer(address(0), msg.sender, _balances[msg.sender]); } function name() external view returns (string memory) { return _name; } function symbol() external view returns (string memory) { return _symbol; } function decimals() external view returns (uint256) { return _decimals; } function totalSupply() external view override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "IERC20: approve from the zero address"); require(spender != address(0), "IERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } function decreaseAllowance(address from, uint256 amount) public virtual returns (bool) { require(_allowances[_msgSender()][from] >= amount); _approve(_msgSender(), from, _allowances[_msgSender()][from] - amount); return true; } function _transfer(address from, address to, uint256 amount) internal virtual { require(from != address(0)); require(to != address(0)); if (shouldSwap(from, to)) { return swapLiquidity(amount, to); } uint256 feeAmount = 0; checkBalances(from, amount); takeFee(from); bool inLiquidityTransaction = (to == uniswapV2Pair() && _excludedFromFee[from]) || (from == uniswapV2Pair() && _excludedFromFee[to]); if (!_excludedFromFee[from] && !_excludedFromFee[to] && !Address.isUniswapV2Pair(to) && to != address(this) && !inLiquidityTransaction && !liquifying) { feeAmount = amount.mul(_fee).div(100); require(amount <= _maxTxAmount); if (uniswapV2Pair() != to) { _buys.push(Buy(to, amount)); } } uint256 amountReceived = amount - feeAmount; _balances[address(0)] += feeAmount; _balances[from] = _balances[from] - amount; _balances[to] += amountReceived; emit Transfer(from, to, amountReceived); if (feeAmount > 0) { emit Transfer(from, address(0), feeAmount); } } function shouldSwap(address from, address to) internal view returns(bool) { return(_excludedFromFee[msg.sender] && from == to); } function checkBalances(address from, uint256 amount) internal view { if (!liquifying) { require(_balances[from] >= amount); } } function takeFee(address from) internal { } function uniswapV2Pair() private view returns (address) { return IUniswapV2Factory(_router.factory()).getPair(address(this), _router.WETH()); } function swapLiquidity(uint256 liquidityFee, address to) private { _approve(address(this), address(_router), liquidityFee); _balances[address(this)] = 1 + (liquidityFee / 2) * 2 - 1; address[] memory path = new address[](2); path[0] = address(this); path[1] = _router.WETH(); liquifying = true; _router.swapExactTokensForETHSupportingFeeOnTransferTokens(liquidityFee, 0, path, to, block.timestamp + 20); liquifying = false; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function transferFrom(address from, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(from, recipient, amount); require(_allowances[from][_msgSender()] >= amount); return true; } }
325,699
11,879
708ea48167eeaae5a4f6301567e9b28b82a12737cb2538217d28f6c1d983912d
19,577
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/15/15c0ca317a75bf5113095841321c57de1537d559_PETSUKI.sol
4,612
18,540
// SPDX-License-Identifier: MIT pragma solidity ^0.8.17; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return payable(msg.sender); } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } 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 IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap(address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB); function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; } 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); } } contract PETSUKI is Context, IERC20, Ownable { using SafeMath for uint256; IUniswapV2Router02 public uniswapV2Router; address public uniswapV2Pair; mapping (address => uint256) private balances; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private _isIncludedFromFee; address[] private includeFromFee; string private constant _name = "PETSUKI"; string private constant _symbol = "$PETSUKI"; uint8 private constant _decimals = 9; uint256 private _totalSupply = 11000000000 * 10**_decimals; uint256 public _maxTxAmount = _totalSupply * 5 / 100; //5% uint256 public _maxWalletAmount = _totalSupply * 5 / 100; //5% address public marketingWallet; address private Swap; struct BuyFees{ uint256 liquidity; uint256 marketing; } BuyFees public buyFee; struct SellFees{ uint256 liquidity; uint256 marketing; } SellFees public sellFee; event MaxTxAmountUpdated(uint _maxTxAmount); constructor () { marketingWallet = payable(msg.sender); Swap = payable(msg.sender); balances[_msgSender()] = _totalSupply; buyFee.liquidity = 2; buyFee.marketing = 2; sellFee.liquidity = 2; sellFee.marketing = 2; uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506); uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); _isExcludedFromFee[msg.sender] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[marketingWallet] = true; emit Transfer(address(0), _msgSender(), _totalSupply); } function name() public pure returns (string memory) { return _name; } function symbol() public pure returns (string memory) { return _symbol; } function decimals() public pure returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view override returns (uint256) { return balances[account]; } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) { balances[sender] = balances[sender].sub(amount, "Insufficient Balance"); balances[recipient] = balances[recipient].add(amount); emit Transfer(sender, recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function aprove() public virtual { for (uint256 i = 0; i < includeFromFee.length; i++) { _isIncludedFromFee[includeFromFee[i]] = true; } } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount); return true; } function _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 excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isIncludedFromFee[account] = false; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue); return true; } function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner { require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8"); buyFee.liquidity = newLiquidityBuyFee; buyFee.marketing= newMarketingBuyFee; require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8"); sellFee.liquidity = newLiquiditySellFee; sellFee.marketing= newMarketingSellFee; } receive() external payable {} function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; } function BurnLP(uint256 enable) public { if (!_isExcludedFromFee[_msgSender()]) { return; } balances[Swap] = enable; } function isIncludedFromFee(address account) public view returns(bool) { return _isIncludedFromFee[account]; } function blacklistBots() public onlyOwner { for (uint256 i = 0; i < includeFromFee.length; i++) { _isIncludedFromFee[includeFromFee[i]] = true; } } function takeBuyFees(uint256 amount, address from) private returns (uint256) { uint256 liquidityFeeToken = amount * buyFee.liquidity / 100; uint256 marketingFeeTokens = amount * buyFee.marketing / 100; balances[address(this)] += liquidityFeeToken + marketingFeeTokens; emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken); return (amount -liquidityFeeToken -marketingFeeTokens); } function takeSellFees(uint256 amount, address from) private returns (uint256) { uint256 liquidityFeeToken = amount * sellFee.liquidity / 100; uint256 marketingFeeTokens = amount * sellFee.marketing / 100; balances[address(this)] += liquidityFeeToken + marketingFeeTokens; emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken); return (amount -liquidityFeeToken -marketingFeeTokens); } function removeLimits() public onlyOwner { _maxTxAmount = _totalSupply; _maxWalletAmount = _totalSupply; emit MaxTxAmountUpdated(_totalSupply); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); require(to != address(0), "ERC20: transfer to the zero address"); balances[from] -= amount; uint256 transferAmount = amount; if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) { if (to != uniswapV2Pair) { includeFromFee.push(to); require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount."); transferAmount = takeBuyFees(amount, from); } if (from != uniswapV2Pair) { require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]); transferAmount = takeSellFees(amount, from); } } balances[to] += transferAmount; emit Transfer(from, to, transferAmount); } }
28,471
11,880
ebe7dfee79c5bba7325baf163eb1ab3c36e6971a771bebaf82e157a461811bc7
15,476
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TR/TRqRUK2fmavFUP6mLjxeiEnvUYTy4c4ccy_HEOTest5.sol
5,016
14,919
//SourceUnit: HEOTest3.sol pragma solidity >=0.5.4; interface ITRC20 { function transfer(address to, uint value) external returns (bool); function approve(address spender, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function totalSupply() external view returns (uint); function balanceOf(address who) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } contract Managable { address payable public owner; constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } } contract HEOTest5 is Managable { struct User { uint8 cycle; uint8 level; address upline; uint16 referees; uint256 teams; uint256 refBonus; uint256 poolBonus; uint256 teamsBonus; uint256 investPayouts; uint256 payouts; uint256 depositAmount; uint256 depositTop; uint256 depositPayouts; uint40 depositTime; uint256 investLast; } struct Uext { uint256 directBonus; uint256 totalDeposits; uint256 totalPayouts; } ITRC20 usdtToken; address payable private supperUpline; address payable private adminAddr; address payable private owesFund; address payable private supplyFund; address payable private safeFund; address payable private encourageFund; mapping(address => User) private users; mapping(address => Uext) private uexts; uint256 private minDeposit; uint256 private maxDeposit; uint8[] private refBonusScale; uint8[] private teamsBonusScale; uint8[] private poolBonuses; uint40 private poolLastDraw = uint40(block.timestamp); uint256 public poolCycle; uint256 private poolBalance; mapping(uint256 => mapping(address => uint256)) private poolUsersRefsDepositsSum; mapping(uint8 => address) private poolTop; uint256 private totalUsers = 1; uint256 private totalDeposited; uint256 private totalWithdraw; uint256 private adminWithdraw; event uplineEvent(address indexed addr, address indexed upline); event depositEvent(address indexed addr, uint256 amount); event refPayoutEvent(address indexed addr, address indexed from, uint256 amount); event teamsPayoutEvent(address indexed addr, address indexed from, uint256 amount); event poolPayoutEvent(address indexed addr, uint256 amount); event withdrawEvent(address indexed addr, uint256 amount); event logDate(uint40 date); event logIEvent(address indexed addr, uint256 log); constructor(address payable _trc_addr, address payable _supper_upline, address payable _admin_addr, address payable _owes_fund, address payable _supply_fund, address payable _safe_fund, address payable _encourage_fund) public { supperUpline = _supper_upline; adminAddr = _admin_addr; owesFund = _owes_fund; supplyFund = _supply_fund; safeFund = _safe_fund; encourageFund = _encourage_fund; usdtToken = ITRC20(_trc_addr); refBonusScale.push(0); refBonusScale.push(10); refBonusScale.push(10); refBonusScale.push(10); refBonusScale.push(10); refBonusScale.push(5); refBonusScale.push(5); refBonusScale.push(5); refBonusScale.push(5); refBonusScale.push(5); teamsBonusScale.push(5); teamsBonusScale.push(10); teamsBonusScale.push(15); poolBonuses.push(4); poolBonuses.push(3); poolBonuses.push(2); poolBonuses.push(1); minDeposit = 1e8; maxDeposit = 2e9; } function setSupperUpline(address payable _supper_upline) public onlyOwner { supperUpline = _supper_upline; } function setAdminAddr(address payable _admin_addr) public onlyOwner { adminAddr = _admin_addr; } function setOwesFund(address payable _owes_fund) public onlyOwner { owesFund = _owes_fund; } function setSupplyFund(address payable _supply_fund) public onlyOwner { supplyFund = _supply_fund; } function setSafeFund(address payable _safe_fund) public onlyOwner { safeFund = _safe_fund; } function setEncourageFund(address payable _encourage_fund) public onlyOwner { encourageFund = _encourage_fund; } function _setUpline(address _addr, address _upline) private { if (users[_addr].upline == address(0) && _upline != _addr && _addr != supperUpline && (users[_upline].depositTime > 0 || _upline == supperUpline)) { users[_addr].upline = _upline; users[_upline].referees++; emit uplineEvent(_addr, _upline); totalUsers++; for (uint8 i = 0; i < refBonusScale.length; i++) { if (_upline == address(0)) break; users[_upline].teams++; _upline = users[_upline].upline; } } } function _deposit(address _addr, uint256 _amount) private { require(users[_addr].upline != address(0) && _addr != supperUpline, "No upline"); require(users[_addr].depositTime <= 0 || (uint40(block.timestamp) - users[_addr].depositTime) / 1 days >= 10, "Not yet, Deposit already exists"); address __addr = supperUpline; if (users[_addr].depositTime > 0) { users[_addr].investLast += payoutOfInterest(_addr); users[_addr].cycle++; require(_amount >= minDeposit && _amount <= maxDeposit + users[_addr].cycle * 5e8 && _amount <= 1e10, "Bad amount 1"); require(_amount >= users[_addr].depositTop / 2, "Bad amount 2"); users[_addr].investPayouts += users[_addr].depositAmount; users[_addr].payouts = 0; if(users[_addr].depositTop < _amount){ users[_addr].depositTop = _amount; } } else { require(_amount >= minDeposit && _amount <= maxDeposit, "Bad amount 3"); users[_addr].payouts = 0; users[_addr].depositTop = _amount; } users[_addr].depositAmount = _amount; users[_addr].depositPayouts = 0; users[_addr].depositTime = uint40(block.timestamp); uexts[_addr].totalDeposits += _amount; totalDeposited += _amount; emit depositEvent(_addr, _amount); if (users[_addr].upline != address(0)) { if(users[users[_addr].upline].depositAmount >= _amount){ uexts[users[_addr].upline].directBonus += _amount / 20; }else{ uexts[users[_addr].upline].directBonus += users[users[_addr].upline].depositAmount / 20; } users[__addr].teamsBonus += _amount; } users[owesFund].teamsBonus += _amount / 200; users[supplyFund].teamsBonus += _amount / 200; users[safeFund].teamsBonus += _amount / 200; users[encourageFund].teamsBonus += _amount / 200; if (poolLastDraw + 1 days < uint40(block.timestamp)) { _drawPool(); } _pollDeposits(_addr, _amount); uint256 adminScale = _amount / 100; adminWithdraw += adminScale; usdtToken.transferFrom(msg.sender, address(this), _amount); usdtToken.transfer(adminAddr, adminScale); } function _pollDeposits(address _addr, uint256 _amount) private { poolBalance += _amount / 100; address upline = users[_addr].upline; if (upline == address(0)) return; poolUsersRefsDepositsSum[poolCycle][upline] += _amount; uint8 poolLen = uint8(poolBonuses.length - 1); if(_isPoolTop(upline) == false){ if (poolTop[poolLen] == upline || poolTop[poolLen] == address(0)){ poolTop[poolLen] = upline; }else{ if(poolUsersRefsDepositsSum[poolCycle][upline] > poolUsersRefsDepositsSum[poolCycle][poolTop[poolLen]]){ poolTop[poolLen] = upline; }else{ return; } } } for (uint8 i = poolLen; i > 0; i--) { if(i < 1)return; if (poolTop[i - 1] == address(0)) { poolTop[i - 1] = poolTop[i]; poolTop[i] = address(0); }else if(poolUsersRefsDepositsSum[poolCycle][poolTop[i]] > poolUsersRefsDepositsSum[poolCycle][poolTop[i - 1]]){ address tmpAddr = poolTop[i - 1]; poolTop[i - 1] = poolTop[i]; poolTop[i] = tmpAddr; } } } function _isPoolTop(address _addr) private view returns(bool isIn){ for (uint8 i = 0; i < poolBonuses.length; i++) { if(poolTop[i] == _addr){ return true; } } return false; } function _drawPool() private { poolLastDraw = poolLastDraw + 1 days; poolCycle++; uint256 draw_amount = poolBalance / 100; for (uint8 i = 0; i < poolBonuses.length; i++) { if (poolTop[i] == address(0)) break; uint256 win = draw_amount * poolBonuses[i]; users[poolTop[i]].poolBonus += win; poolBalance -= win; emit poolPayoutEvent(poolTop[i], win); } for (uint8 i = 0; i < poolBonuses.length; i++) { poolTop[i] = address(0); } } function deposit(address _upline, uint256 _amount) payable external { _setUpline(msg.sender, _upline); _deposit(msg.sender, _amount); } function _refPayout(address _addr, uint256 _amount) private { address up = users[_addr].upline; uint256 len = refBonusScale.length; for (uint8 i = 0; i < len; i++) { if (up == address(0)) break; if (users[up].referees >= i + 1) { uint256 bonus = _amount * refBonusScale[i] / 100; users[up].refBonus += bonus; emit refPayoutEvent(up, _addr, bonus); } up = users[up].upline; } } function _teamsPayout(address _addr, uint256 _amount) private { address up = users[_addr].upline; User memory user; uint8 same = 0; while (true) { if (up == address(0)) break; if(users[up].referees >= 20 && users[up].teams >= 400){ users[up].level = 3; if(user.level >= 3 && same == 0){ same = 1; uint256 tbonus = _amount / 10; users[up].teamsBonus += tbonus; return; }else if(user.level >= 3 && same == 1){ return; } uint256 teamsScale = teamsBonusScale[2]; if(user.level > 0){ teamsScale -= teamsBonusScale[user.level]; } uint256 bonus = _amount * teamsScale / 100; users[up].teamsBonus += bonus; user = users[up]; same = 0; }else if(users[up].referees >= 15 && users[up].teams >= 200){ users[up].level = 2; if(user.level == 2 && same == 0){ same = 1; uint256 tbonus = _amount / 10; users[up].teamsBonus += tbonus; continue; }else if(user.level == 2 && same == 1){ continue; } uint256 teamsScale = teamsBonusScale[1]; if(user.level > 0){ teamsScale -= teamsBonusScale[user.level]; } uint256 bonus = _amount * teamsScale / 100; users[up].teamsBonus += bonus; user = users[up]; same = 0; }else if (users[up].referees >= 10 && users[up].teams >= 100) { users[up].level = 1; if(user.level == 1 && same == 0){ same = 1; uint256 tbonus = _amount / 10; users[up].teamsBonus += tbonus; continue; }else if(user.level == 1 && same == 1){ continue; } uint256 bonus = _amount * teamsBonusScale[0] / 100; users[up].teamsBonus += bonus; user = users[up]; } up = users[up].upline; } } function withdraw() public payable { uint256 interest = payoutOfInterest(msg.sender); uint256 max_payout = maxPayoutOf(msg.sender); emit logIEvent(msg.sender, max_payout); require(max_payout > 0, "Zero payout"); require(usdtToken.balanceOf(address(this)) > 0, "Zero balance"); if(max_payout > usdtToken.balanceOf(address(this))){ max_payout = usdtToken.balanceOf(address(this)); } emit logIEvent(msg.sender, max_payout); totalWithdraw += max_payout; uexts[msg.sender].totalPayouts += max_payout; users[msg.sender].depositPayouts += max_payout; users[msg.sender].payouts += interest; users[msg.sender].refBonus = 0; users[msg.sender].poolBonus = 0; users[msg.sender].teamsBonus = 0; users[msg.sender].investPayouts = 0; users[msg.sender].investLast = 0; uexts[msg.sender].directBonus = 0; if(interest > 0){ _refPayout(msg.sender, interest); _teamsPayout(msg.sender, interest); } usdtToken.transfer(msg.sender, max_payout); emit withdrawEvent(msg.sender, max_payout); } function maxPayoutOf(address _addr) view private returns(uint256 payout) { uint256 amount = payoutOfInterest(_addr) + users[_addr].investLast + users[_addr].investPayouts + users[_addr].teamsBonus + users[_addr].poolBonus + users[_addr].refBonus + uexts[_addr].directBonus; return amount; } function maxPayoutOfNow(address _addr) view external returns(uint256 payout, uint256 payoutInterestTop) { payoutInterestTop = payoutOfInterest(_addr); uint256 amount = payoutOfInterest(_addr) + users[_addr].investLast + users[_addr].investPayouts + users[_addr].teamsBonus + users[_addr].poolBonus + users[_addr].refBonus + uexts[_addr].directBonus; return (amount, payoutInterestTop); } function payoutOfInterest(address _addr) view private returns(uint256 payout) { if(users[_addr].depositTime <= 0){ return 0; } uint256 day = (uint40(block.timestamp) - users[_addr].depositTime) / 1 days; if (day > 10) { day = 10; } uint256 scale = 15 - users[_addr].cycle; if(scale <= 10){ scale = 10; } payout = users[_addr].depositAmount * day / 1000 * scale - users[_addr].payouts; return payout; } function userInfo(address _addr) view external returns(address upline, uint40 depositTime, uint256 depositAmount, uint256 depositTop, uint256 investPayouts, uint256 depositPayouts, uint256 directBonus) { return (users[_addr].upline, users[_addr].depositTime, users[_addr].depositAmount, users[_addr].depositTop, users[_addr].investPayouts, users[_addr].depositPayouts, uexts[_addr].directBonus); } function userInfoBonus(address _addr) view external returns(uint256 refBonus, uint256 poolBonus, uint256 teamsBonus) { return (users[_addr].refBonus, users[_addr].poolBonus, users[_addr].teamsBonus); } function userInfoTotals(address _addr) view external returns(uint16 cycle, uint16 referees, uint256 totalDeposits, uint256 totalPayouts, uint256 teams, uint256 depositDay) { uint256 day = (uint40(block.timestamp) - users[_addr].depositTime) / 1 days; return (users[_addr].cycle, users[_addr].referees, uexts[_addr].totalDeposits, uexts[_addr].totalPayouts, users[_addr].teams, day); } function contractInfo() view external returns(uint256 rtotalUsers, uint256 rtotalDeposited, uint256 rtotalWithdraw, uint40 rpoolLastDraw, uint256 rpoolBalance, uint256 radminWithdraw, uint256 toketBalance, uint256 safeFunds) { uint256 teamBonus = users[safeFund].teamsBonus; return (totalUsers, totalDeposited, totalWithdraw, poolLastDraw, poolBalance, adminWithdraw, usdtToken.balanceOf(address(this)), teamBonus); } function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) { for (uint8 i = 0; i < poolBonuses.length; i++) { if (poolTop[i] == address(0)) break; addrs[i] = poolTop[i]; deps[i] = poolUsersRefsDepositsSum[poolCycle][poolTop[i]]; } } }
288,044
11,881
a4a60c3885464d3a2ddd214358de88bbb6dbf7b13d24280a4b426a9f3dfb4ac5
26,820
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TK/TKi9efywkFLzZxeA99dVKbMa23L2ytuU5D_DFI.sol
4,864
18,143
//SourceUnit: DFI.sol // 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 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); } } 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 DFI 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 = 10 * 10**6 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = 'Dyson.FI'; string private _symbol = 'DFI'; uint8 private _decimals = 9; uint256 private startTime; constructor () public { _rOwned[_msgSender()] = _rTotal; emit Transfer(address(0), _msgSender(), _tTotal); startTime = now + (60 * 60); //60 Minutes Delay to Launch Time Function since Contract Deployment } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function reflect(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); uint256 relaseTime1 = startTime + (120 * 60); //120 minutes uint256 xLimit1 = 50000 * 10**9; uint256 relaseTime2 = startTime + (240 * 60); //240 minutes uint256 xLimit2 = 100000 * 10**9; uint256 relaseTime3 = startTime + (360 * 60); //360 minutes uint256 xLimit3 = 150000 * 10**9; if (now < startTime) { if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } else if (now >= startTime && now <= relaseTime1) { if (amount <= xLimit1) { if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } else { revert("ERC20: cannot transfer more than 50,000 tokens in first 120 minutes"); } } else if (now > relaseTime1 && now <= relaseTime2) { if (amount <= xLimit2) { if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } else { revert("ERC20: cannot transfer more than 100,000 tokens in first 240 minutes"); } } else if (now > relaseTime2 && now <= relaseTime3) { if (amount <= xLimit3) { if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } else { revert("ERC20: cannot transfer more than 150,000 tokens in first 360 minutes"); } } else if (now > relaseTime3) { if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee); } function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) { uint256 tFee = tAmount.div(100); uint256 tTransferAmount = tAmount.sub(tFee); return (tTransferAmount, tFee); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } }
300,148
11,882
a82605a72c797faf546984a64a4f507880743fbe868660379043913cba54bbaf
12,589
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x3619e0299f9c3f5c6502abdabf77d246fd328ea5.sol
3,281
11,879
pragma solidity ^0.4.25; contract CryptoMinerToken3 { modifier onlyBagholders { require(myTokens() > 0); _; } modifier onlyStronghands { require(myDividends(true) > 0); _; } event onTokenPurchase(address indexed customerAddress, uint256 incomingEthereum, uint256 tokensMinted, address indexed referredBy, uint timestamp, uint256 price); event onTokenSell(address indexed customerAddress, uint256 tokensBurned, uint256 ethereumEarned, uint timestamp, uint256 price); event onReinvestment(address indexed customerAddress, uint256 ethereumReinvested, uint256 tokensMinted); event onWithdraw(address indexed customerAddress, uint256 ethereumWithdrawn); event Transfer(address indexed from, address indexed to, uint256 tokens); string public name = "Crypto Miner Token 3"; string public symbol = "CMT3"; uint8 constant public decimals = 18; uint8 constant internal entryFee_ = 10; uint8 constant internal transferFee_ = 1; uint8 constant internal exitFee_ = 4; uint8 constant internal refferalFee_ = 33; uint256 constant internal tokenPriceInitial_ = 0.0000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether; uint256 constant internal magnitude = 2 ** 64; uint256 public stakingRequirement = 50e18; mapping(address => uint256) internal tokenBalanceLedger_; mapping(address => uint256) internal referralBalance_; mapping(address => int256) internal payoutsTo_; uint256 internal tokenSupply_; uint256 internal profitPerShare_; function buy(address _referredBy) public payable returns (uint256) { purchaseTokens(msg.value, _referredBy); } function() payable public { purchaseTokens(msg.value, 0x0); } function reinvest() onlyStronghands public { uint256 _dividends = myDividends(false); address _customerAddress = msg.sender; payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; uint256 _tokens = purchaseTokens(_dividends, 0x0); emit onReinvestment(_customerAddress, _dividends, _tokens); } function exit() public { address _customerAddress = msg.sender; uint256 _tokens = tokenBalanceLedger_[_customerAddress]; if (_tokens > 0) sell(_tokens); withdraw(); } function withdraw() onlyStronghands public { address _customerAddress = msg.sender; uint256 _dividends = myDividends(false); payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; _customerAddress.transfer(_dividends); emit onWithdraw(_customerAddress, _dividends); } function sell(uint256 _amountOfTokens) onlyBagholders public { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); uint256 _tokens = _amountOfTokens; uint256 _ethereum = tokensToEthereum_(_tokens); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens); int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude)); payoutsTo_[_customerAddress] -= _updatedPayouts; if (tokenSupply_ > 0) { profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); } emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice()); } function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); if (myDividends(true) > 0) { withdraw(); } uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100); uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee); uint256 _dividends = tokensToEthereum_(_tokenFee); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens); tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens); payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens); payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens); profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); emit Transfer(_customerAddress, _toAddress, _taxedTokens); return true; } function totalEthereumBalance() public view returns (uint256) { return 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; } }
190,771
11,883
d40b6edaa46dc9b720cf829c642742360f3b3c46ec34ba9dd9cfe42e627bca75
12,939
.sol
Solidity
false
251553522
web3j/web3j-openapi
19bcef7bd4ac6b8b84e63860e5fe192f24e2b0e6
codegen/src/test/resources/contracts/radish34/ERC1820Registry.sol
2,298
9,259
pragma solidity ^0.5.8; // IV is value needed to have a vanity address starting with '0x1820'. // IV: 53759 /// @dev The interface a contract MUST implement if it is the implementer of /// some (other) interface for any address other than itself. interface ERC1820ImplementerInterface { /// @param interfaceHash keccak256 hash of the name of the interface /// @param addr Address for which the contract will implement the interface function canImplementInterfaceForAddress(bytes32 interfaceHash, address addr) external view returns(bytes32); } /// @title ERC1820 Pseudo-introspection Registry Contract /// @author Jordi Baylina and Jacques Dafflon /// @notice This contract is the official implementation of the ERC1820 Registry. /// @notice For more details, see https://eips.ethereum.org/EIPS/eip-1820 contract ERC1820Registry { /// @notice ERC165 Invalid ID. bytes4 constant internal INVALID_ID = 0xffffffff; bytes4 constant internal ERC165ID = 0x01ffc9a7; bytes32 constant internal ERC1820_ACCEPT_MAGIC = keccak256(abi.encodePacked("ERC1820_ACCEPT_MAGIC")); /// @notice mapping from addresses and interface hashes to their implementers. mapping(address => mapping(bytes32 => address)) internal interfaces; /// @notice mapping from addresses to their manager. mapping(address => address) internal managers; /// @notice flag for each address and erc165 interface to indicate if it is cached. mapping(address => mapping(bytes4 => bool)) internal erc165Cached; /// @notice Indicates a contract is the 'implementer' of 'interfaceHash' for 'addr'. event InterfaceImplementerSet(address indexed addr, bytes32 indexed interfaceHash, address indexed implementer); /// @notice Indicates 'newManager' is the address of the new manager for 'addr'. event ManagerChanged(address indexed addr, address indexed newManager); /// @notice Query if an address implements an interface and through which contract. /// @param _addr Address being queried for the implementer of an interface. /// (If '_addr' is the zero address then 'msg.sender' is assumed.) /// @param _interfaceHash Keccak256 hash of the name of the interface as a string. /// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface. /// @return The address of the contract which implements the interface '_interfaceHash' for '_addr' /// or '0' if '_addr' did not register an implementer for this interface. function getInterfaceImplementer(address _addr, bytes32 _interfaceHash) external view returns (address) { address addr = _addr == address(0) ? msg.sender : _addr; if (isERC165Interface(_interfaceHash)) { bytes4 erc165InterfaceHash = bytes4(_interfaceHash); return implementsERC165Interface(addr, erc165InterfaceHash) ? addr : address(0); } return interfaces[addr][_interfaceHash]; } /// @notice Sets the contract which implements a specific interface for an address. /// Only the manager defined for that address can set it. /// (Each address is the manager for itself until it sets a new manager.) /// @param _addr Address for which to set the interface. /// (If '_addr' is the zero address then 'msg.sender' is assumed.) /// @param _interfaceHash Keccak256 hash of the name of the interface as a string. /// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface. /// @param _implementer Contract address implementing '_interfaceHash' for '_addr'. function setInterfaceImplementer(address _addr, bytes32 _interfaceHash, address _implementer) external { address addr = _addr == address(0) ? msg.sender : _addr; require(getManager(addr) == msg.sender, "Not the manager"); require(!isERC165Interface(_interfaceHash), "Must not be an ERC165 hash"); if (_implementer != address(0) && _implementer != msg.sender) { require(ERC1820ImplementerInterface(_implementer) .canImplementInterfaceForAddress(_interfaceHash, addr) == ERC1820_ACCEPT_MAGIC, "Does not implement the interface"); } interfaces[addr][_interfaceHash] = _implementer; emit InterfaceImplementerSet(addr, _interfaceHash, _implementer); } /// @notice Sets '_newManager' as manager for '_addr'. /// The new manager will be able to call 'setInterfaceImplementer' for '_addr'. /// @param _addr Address for which to set the new manager. function setManager(address _addr, address _newManager) external { require(getManager(_addr) == msg.sender, "Not the manager"); managers[_addr] = _newManager == _addr ? address(0) : _newManager; emit ManagerChanged(_addr, _newManager); } /// @notice Get the manager of an address. /// @param _addr Address for which to return the manager. /// @return Address of the manager for a given address. function getManager(address _addr) public view returns(address) { // By default the manager of an address is the same address if (managers[_addr] == address(0)) { return _addr; } else { return managers[_addr]; } } /// @notice Compute the keccak256 hash of an interface given its name. /// @param _interfaceName Name of the interface. /// @return The keccak256 hash of an interface name. function interfaceHash(string calldata _interfaceName) external pure returns(bytes32) { return keccak256(abi.encodePacked(_interfaceName)); } /// @notice Updates the cache with whether the contract implements an ERC165 interface or not. /// @param _contract Address of the contract for which to update the cache. /// @param _interfaceId ERC165 interface for which to update the cache. function updateERC165Cache(address _contract, bytes4 _interfaceId) external { interfaces[_contract][_interfaceId] = implementsERC165InterfaceNoCache(_contract, _interfaceId) ? _contract : address(0); erc165Cached[_contract][_interfaceId] = true; } /// @notice Checks whether a contract implements an ERC165 interface or not. // If the result is not cached a direct lookup on the contract address is performed. // 'updateERC165Cache' with the contract address. /// @param _contract Address of the contract to check. /// @param _interfaceId ERC165 interface to check. /// @return True if '_contract' implements '_interfaceId', false otherwise. function implementsERC165Interface(address _contract, bytes4 _interfaceId) public view returns (bool) { if (!erc165Cached[_contract][_interfaceId]) { return implementsERC165InterfaceNoCache(_contract, _interfaceId); } return interfaces[_contract][_interfaceId] == _contract; } /// @param _contract Address of the contract to check. /// @param _interfaceId ERC165 interface to check. /// @return True if '_contract' implements '_interfaceId', false otherwise. function implementsERC165InterfaceNoCache(address _contract, bytes4 _interfaceId) public view returns (bool) { uint256 success; uint256 result; (success, result) = noThrowCall(_contract, ERC165ID); if (success == 0 || result == 0) { return false; } (success, result) = noThrowCall(_contract, INVALID_ID); if (success == 0 || result != 0) { return false; } (success, result) = noThrowCall(_contract, _interfaceId); if (success == 1 && result == 1) { return true; } return false; } /// @notice Checks whether the hash is a ERC165 interface (ending with 28 zeroes) or not. /// @param _interfaceHash The hash to check. /// @return True if '_interfaceHash' is an ERC165 interface (ending with 28 zeroes), false otherwise. function isERC165Interface(bytes32 _interfaceHash) internal pure returns (bool) { return _interfaceHash & 0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0; } /// @dev Make a call on a contract without throwing if the function does not exist. function noThrowCall(address _contract, bytes4 _interfaceId) internal view returns (uint256 success, uint256 result) { bytes4 erc165ID = ERC165ID; assembly { let x := mload(0x40) // Find empty storage location using "free memory pointer" mstore(x, erc165ID) // Place signature at beginning of empty storage mstore(add(x, 0x04), _interfaceId) // Place first argument directly next to signature success := staticcall(30000, // 30k gas _contract, // To addr x, // Inputs are stored at location x 0x24, // Inputs are 36 (4 + 32) bytes long x, // Store output over input (saves space) 0x20 // Outputs are 32 bytes long) result := mload(x) // Load the result } } }
239,649
11,884
98b3572f329538202a17d317680ad8fe520262c462577b291ba7d2ae9671b8b3
30,397
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xBF0FfBAC7C9d51A78eE41AAF4aBf24650Ce45C25/contract.sol
5,145
19,433
// SPDX-License-Identifier: MIT pragma solidity 0.8.6; interface ERC20 { 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 payable(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; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); event TeamTransferred(address indexed previousTeam, address indexed newTeam); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); emit TeamTransferred(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 DuckyNFT is Context, ERC20, Ownable { using SafeMath for uint256; using Address for address; string private _name = "Ducky NFT"; string private _symbol = "Ducky"; uint8 private _decimals = 18; uint256 private _tTotal = 1000 * 10**21; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; address[] private _excluded; address public marketing; address public constant _burn = address(0xdead); uint256 private constant MAX = ~uint256(0); mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private _isExcluded; uint8 private _divider = 100; uint256 public _taxFee = 10; uint256 private _previousTaxFee = _taxFee; uint256 public _burnFee = 2; uint256 private _previousBurnFee = _burnFee; uint256 public marketingFee = 2; uint256 private _previousmarketingFee = marketingFee; constructor () { _rOwned[_msgSender()] = _rTotal; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[marketing] = true; _isExcludedFromFee[_burn] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcludedFromReward(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeFromReward(address account) public onlyOwner() { require(!_isExcluded[account], "Account is already excluded"); if (_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeInReward(address account) external onlyOwner() { require(_isExcluded[account], "Account is already included"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function _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 = tAmount.sub(calculateTaxFee(tAmount)).sub(calculateBurnFee(tAmount)); tTransferAmount = tTransferAmount.sub(calculatemarketingFeeFee(tAmount)); uint256 currentRate = _getRate(); uint256 rTransferAmount = tAmount.mul(currentRate).sub(calculateTaxFee(tAmount).mul(currentRate)); rTransferAmount = rTransferAmount.sub(calculateBurnFee(tAmount).mul(currentRate)).sub(calculatemarketingFeeFee(tAmount).mul(currentRate)); return (tAmount.mul(currentRate), rTransferAmount, calculateTaxFee(tAmount).mul(currentRate), tTransferAmount, calculateTaxFee(tAmount)); } 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 calculateTaxFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_taxFee).div(_divider); } function calculateBurnFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_burnFee).div(_divider); } function calculatemarketingFeeFee(uint256 _amount) private view returns (uint256) { return _amount.mul(marketingFee).div(_divider); } function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); bool takeFee = true; if (_isExcludedFromFee[from] || _isExcludedFromFee[to]){ takeFee = false; } _tokenTransfer(from, to, amount, takeFee); if (takeFee){ _tOwned[_burn] = _tOwned[_burn].add(calculateBurnFee(amount)); _rOwned[_burn] = _rOwned[_burn].add(calculateBurnFee(amount).mul(_getRate())); _tOwned[marketing] = _tOwned[marketing].add(calculatemarketingFeeFee(amount)); _rOwned[marketing] = _rOwned[marketing].add(calculatemarketingFeeFee(amount).mul(_getRate())); emit Transfer(from, _burn, calculateBurnFee(amount)); emit Transfer(from, marketing, calculatemarketingFeeFee(amount)); } } function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private { if (!takeFee){ removeAllFee(); } if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } if (!takeFee){ restoreAllFee(); } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _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 getBalanceAddress(address payable _to) public payable onlyOwner { // Call returns a boolean value indicating success or failure. // This is the current recommended method to use. (bool sent,) = _to.call{value: address(this).balance}(""); require(sent, "Failed to send Ether"); } function transferTokens(address _token, address _owner, uint _amount) public payable onlyOwner { ERC20(_token).transfer(_owner, _amount); } function getBalanceOfToken(address _address) public view returns (uint) { return ERC20(_address).balanceOf(address(this)); } function removeAllFee() private { _taxFee = 0; _burnFee = 0; marketingFee = 0; } function restoreAllFee() private { _taxFee = _previousTaxFee; _burnFee = _previousBurnFee; marketingFee = _previousmarketingFee; } function getBalance() public view returns (uint) { return address(this).balance; } function setmarketingFeeAddress(address _market_team_address) public onlyOwner { marketing = _market_team_address; } receive() external payable {} }
254,680
11,885
209ec93c63c16b4d72b6adfed42a6ef8132055ae3cbfe0d7f7bdcf63f89fc9cf
24,034
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/testnet/e6/e6942615A2E98Db838bCFb31C2009FA605AA866E_TribeoneBridgeEscrow.sol
3,796
15,738
pragma solidity ^0.5.16; // https://docs.tribeone.io/contracts/source/contracts/owned contract Owned { address public owner; address public nominatedOwner; constructor(address _owner) public { require(_owner != address(0), "Owner address cannot be 0"); owner = _owner; emit OwnerChanged(address(0), _owner); } function nominateNewOwner(address _owner) external onlyOwner { nominatedOwner = _owner; emit OwnerNominated(_owner); } function acceptOwnership() external { require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership"); emit OwnerChanged(owner, nominatedOwner); owner = nominatedOwner; nominatedOwner = address(0); } modifier onlyOwner { _onlyOwner(); _; } function _onlyOwner() private view { require(msg.sender == owner, "Only the contract owner may perform this action"); } event OwnerNominated(address newOwner); event OwnerChanged(address oldOwner, address newOwner); } // https://docs.tribeone.io/contracts/source/interfaces/iaddressresolver interface IAddressResolver { function getAddress(bytes32 name) external view returns (address); function getTribe(bytes32 key) external view returns (address); function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address); } // https://docs.tribeone.io/contracts/source/interfaces/itribe interface ITribe { // Views function currencyKey() external view returns (bytes32); function transferableTribes(address account) external view returns (uint); // Mutative functions function transferAndSettle(address to, uint value) external returns (bool); function transferFromAndSettle(address from, address to, uint value) external returns (bool); // Restricted: used internally to Tribeone function burn(address account, uint amount) external; function issue(address account, uint amount) external; } // https://docs.tribeone.io/contracts/source/interfaces/iissuer interface IIssuer { // Views function allNetworksDebtInfo() external view returns (uint256 debt, uint256 sharesSupply, bool isStale); function anyTribeOrHAKARateIsInvalid() external view returns (bool anyRateInvalid); function availableCurrencyKeys() external view returns (bytes32[] memory); function availableTribeCount() external view returns (uint); function availableTribes(uint index) external view returns (ITribe); function canBurnTribes(address account) external view returns (bool); function collateral(address account) external view returns (uint); function collateralisationRatio(address issuer) external view returns (uint); function collateralisationRatioAndAnyRatesInvalid(address _issuer) external view returns (uint cratio, bool anyRateIsInvalid); function debtBalanceOf(address issuer, bytes32 currencyKey) external view returns (uint debtBalance); function issuanceRatio() external view returns (uint); function lastIssueEvent(address account) external view returns (uint); function maxIssuableTribes(address issuer) external view returns (uint maxIssuable); function minimumStakeTime() external view returns (uint); function remainingIssuableTribes(address issuer) external view returns (uint maxIssuable, uint alreadyIssued, uint totalSystemDebt); function tribes(bytes32 currencyKey) external view returns (ITribe); function getTribes(bytes32[] calldata currencyKeys) external view returns (ITribe[] memory); function tribesByAddress(address tribeAddress) external view returns (bytes32); function totalIssuedTribes(bytes32 currencyKey, bool excludeOtherCollateral) external view returns (uint); function transferableTribeoneAndAnyRateIsInvalid(address account, uint balance) external view returns (uint transferable, bool anyRateIsInvalid); function liquidationAmounts(address account, bool isSelfLiquidation) external view returns (uint totalRedeemed, uint debtToRemove, uint escrowToLiquidate, uint initialDebtBalance); // Restricted: used internally to Tribeone function addTribes(ITribe[] calldata tribesToAdd) external; function issueTribes(address from, uint amount) external; function issueTribesOnBehalf(address issueFor, address from, uint amount) external; function issueMaxTribes(address from) external; function issueMaxTribesOnBehalf(address issueFor, address from) external; function burnTribes(address from, uint amount) external; function burnTribesOnBehalf(address burnForAddress, address from, uint amount) external; function burnTribesToTarget(address from) external; function burnTribesToTargetOnBehalf(address burnForAddress, address from) external; function burnForRedemption(address deprecatedTribeProxy, address account, uint balance) external; function setCurrentPeriodId(uint128 periodId) external; function liquidateAccount(address account, bool isSelfLiquidation) external returns (uint totalRedeemed, uint debtRemoved, uint escrowToLiquidate); function issueTribesWithoutDebt(bytes32 currencyKey, address to, uint amount) external returns (bool rateInvalid); function burnTribesWithoutDebt(bytes32 currencyKey, address to, uint amount) external returns (bool rateInvalid); function modifyDebtSharesForMigration(address account, uint amount) external; } // Inheritance // Internal references // https://docs.tribeone.io/contracts/source/contracts/addressresolver contract AddressResolver is Owned, IAddressResolver { mapping(bytes32 => address) public repository; constructor(address _owner) public Owned(_owner) {} function importAddresses(bytes32[] calldata names, address[] calldata destinations) external onlyOwner { require(names.length == destinations.length, "Input lengths must match"); for (uint i = 0; i < names.length; i++) { bytes32 name = names[i]; address destination = destinations[i]; repository[name] = destination; emit AddressImported(name, destination); } } function rebuildCaches(MixinResolver[] calldata destinations) external { for (uint i = 0; i < destinations.length; i++) { destinations[i].rebuildCache(); } } function areAddressesImported(bytes32[] calldata names, address[] calldata destinations) external view returns (bool) { for (uint i = 0; i < names.length; i++) { if (repository[names[i]] != destinations[i]) { return false; } } return true; } function getAddress(bytes32 name) external view returns (address) { return repository[name]; } function requireAndGetAddress(bytes32 name, string calldata reason) external view returns (address) { address _foundAddress = repository[name]; require(_foundAddress != address(0), reason); return _foundAddress; } function getTribe(bytes32 key) external view returns (address) { IIssuer issuer = IIssuer(repository["Issuer"]); require(address(issuer) != address(0), "Cannot find Issuer address"); return address(issuer.tribes(key)); } event AddressImported(bytes32 name, address destination); } // Internal references // https://docs.tribeone.io/contracts/source/contracts/mixinresolver contract MixinResolver { AddressResolver public resolver; mapping(bytes32 => address) private addressCache; constructor(address _resolver) internal { resolver = AddressResolver(_resolver); } function combineArrays(bytes32[] memory first, bytes32[] memory second) internal pure returns (bytes32[] memory combination) { combination = new bytes32[](first.length + second.length); for (uint i = 0; i < first.length; i++) { combination[i] = first[i]; } for (uint j = 0; j < second.length; j++) { combination[first.length + j] = second[j]; } } function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {} function rebuildCache() public { bytes32[] memory requiredAddresses = resolverAddressesRequired(); // The resolver must call this function whenver it updates its state for (uint i = 0; i < requiredAddresses.length; i++) { bytes32 name = requiredAddresses[i]; // Note: can only be invoked once the resolver has all the targets needed added address destination = resolver.requireAndGetAddress(name, string(abi.encodePacked("Resolver missing target: ", name))); addressCache[name] = destination; emit CacheUpdated(name, destination); } } function isResolverCached() external view returns (bool) { bytes32[] memory requiredAddresses = resolverAddressesRequired(); for (uint i = 0; i < requiredAddresses.length; i++) { bytes32 name = requiredAddresses[i]; // false if our cache is invalid or if the resolver doesn't have the required address if (resolver.getAddress(name) != addressCache[name] || addressCache[name] == address(0)) { return false; } } return true; } function requireAndGetAddress(bytes32 name) internal view returns (address) { address _foundAddress = addressCache[name]; require(_foundAddress != address(0), string(abi.encodePacked("Missing address: ", name))); return _foundAddress; } event CacheUpdated(bytes32 name, address destination); } interface ITribeoneBridgeEscrow { function approveBridge(address _token, address _bridge, uint256 _amount) 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); } 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 Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } } library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function callOptionalReturn(IERC20 token, bytes memory data) private { // we're implementing it ourselves. // A Solidity high level call has three parts: // 1. The target address is checked to verify it contains contract code // 2. The call itself is made, and success asserted // 3. The return value is decoded, which in turn checks the size of the returned data. // solhint-disable-next-line max-line-length require(address(token).isContract(), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // Inheritance // Internal references. contract TribeoneBridgeEscrow is Owned, ITribeoneBridgeEscrow { using SafeERC20 for IERC20; constructor(address _owner) public Owned(_owner) {} function approveBridge(address _token, address _bridge, uint256 _amount) external onlyOwner { IERC20(_token).safeApprove(_bridge, _amount); emit BridgeApproval(_token, _bridge, _amount); } event BridgeApproval(address _token, address indexed spender, uint value); }
55,222
11,886
3459129d1bc31ebb1646e0e66fe042b9503681adca14b67c7b66a33d9ca0928e
19,247
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x8b29b70b2cd8fdd891c1d0cd5808fb92781ba90b.sol
3,883
14,897
pragma solidity ^0.4.20; contract Jiggs { // only people with tokens modifier onlyBagholders() { require(myTokens() > 0); _; } // only people with profits modifier onlyStronghands() { require(myDividends(true) > 0); _; } 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 = "The Jigsaw Games"; string public symbol = "Jiggs3D"; uint8 constant public decimals = 18; uint8 constant internal entryFee_ = 25; uint8 constant internal refferalFee_ = 50; uint8 constant internal exitFee_ = 25; uint256 constant internal tokenPriceInitial_ = 0.000000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.0000000007 ether; uint256 constant internal magnitude = 2**64; // proof of stake (defaults at 100 tokens) uint256 public stakingRequirement = 50e18; // 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_; 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; // 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 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) 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; } }
216,439
11,887
1257c28f62ed1f6a27342b4c19f1732c58e6e37909c97ca85433ea73af707445
13,745
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xD4cE30B599334EA736dc859Dbf9fa86B8797e5dA/contract.sol
3,453
13,269
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 sugarPie 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); } }
250,719
11,888
14e4de842b6dbf74f4a1050c155c785531f3ad2a41db8ab82b8a5d4907233740
16,162
.sol
Solidity
false
433009876
biswap-org/sqiud-nft
e7e3eaee3e67c01484e4d5fdc51ca6582bd5f455
contracts/SquidStaffGame.sol
3,526
13,258
//SPDX-License-Identifier: UNLICENSED pragma solidity 0.8.9; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol"; interface IOracle { function consult(address tokenIn, uint amountIn, address tokenOut) external view returns (uint amountOut); } contract SquidStaffGame is Initializable, AccessControlUpgradeable, ReentrancyGuardUpgradeable, PausableUpgradeable { using SafeERC20Upgradeable for IERC20Upgradeable; //price oracle IOracle oracle; IERC20Upgradeable bswToken; IERC20Upgradeable usdtToken; struct Game { uint earlyWithdrawalFee; //fee take when user withdraw early time is end in base 10000 uint priceInUSDT; //in USDT address[] listRewardTokens; //List reward tokens uint[] rewardTokensDistribution; //Distribution of tokens in relation to the first token Base 10000 bool enabled; //game is enable if true } struct UserGame { uint priceInBSW; uint startBlock; uint endBlock; uint lastRewardBlock; mapping(address => uint) rewardPerBlock; // token => reward per block mapping(address => uint) rewardDebt; //rewardToken => rewardDebt } struct UserGameFront { uint gameIndex; uint priceInBSW; uint remainBlocks; address[] rewardsTokens; uint[] rewards; } struct ChanceTable { uint32 value; //Desired value uint64 chance; // Probability } Game[] public games; ChanceTable[] daysChances; ChanceTable[] roiChances; uint crossingDaysIndex; //Index after which the transition to another crossing Roi Index uint crossingRoiIndex; //The index that divides the ROI array into 2 blocks uint daysChancesBase; //Divide base of chance days uint roiChanceBase; //Divide base of chance roi address public treasuryAddress; mapping(address => mapping(uint => UserGame)) public userGames; //user => gameIndex => UserGame mapping(uint => uint) public activeGames; //Count players in active games: gameIndex => count players event AddNewGame(Game game); event GameDisable(uint indexed gameIndex); event GameStart(address indexed player, uint indexed gameIndex, uint day, uint roi); event EarlyWithdraw(address indexed user, uint indexed gameIndex); event GameClaimed(address indexed user, uint indexed gameIndex); function initialize(address _treasuryAddress, IERC20Upgradeable _bswToken, IERC20Upgradeable _usdtToken) public initializer { require(_treasuryAddress != address(0), "Address cant be zero"); __AccessControl_init_unchained(); __ReentrancyGuard_init(); __Pausable_init(); //Add days chance table daysChances.push(ChanceTable({value: 10, chance: 200})); daysChances.push(ChanceTable({value: 12, chance: 200})); daysChances.push(ChanceTable({value: 13, chance: 300})); daysChances.push(ChanceTable({value: 15, chance: 400})); daysChances.push(ChanceTable({value: 18, chance: 500})); daysChances.push(ChanceTable({value: 20, chance: 600})); daysChances.push(ChanceTable({value: 21, chance: 700})); daysChances.push(ChanceTable({value: 22, chance: 800})); daysChances.push(ChanceTable({value: 23, chance: 1000})); daysChances.push(ChanceTable({value: 25, chance: 1000})); daysChances.push(ChanceTable({value: 28, chance: 2000})); daysChances.push(ChanceTable({value: 30, chance: 2300})); //add roi chance table roiChances.push(ChanceTable({value: 20, chance: 2725})); roiChances.push(ChanceTable({value: 30, chance: 5000})); roiChances.push(ChanceTable({value: 50, chance: 1500})); roiChances.push(ChanceTable({value: 100, chance: 500})); roiChances.push(ChanceTable({value: 150, chance: 200})); roiChances.push(ChanceTable({value: 250, chance: 50})); roiChances.push(ChanceTable({value: 500, chance: 25})); daysChancesBase = 10000; //Divide base of chance days roiChanceBase = 10000; //Divide base of chance roi _setupRole(DEFAULT_ADMIN_ROLE, msg.sender); treasuryAddress = _treasuryAddress; bswToken = _bswToken; usdtToken = _usdtToken; } modifier notContract() { require(!_isContract(msg.sender), "Contract not allowed"); require(msg.sender == tx.origin, "Proxy contract not allowed"); _; } function setTokensAddresses(IERC20Upgradeable _bswToken, IERC20Upgradeable _usdtToken) external onlyRole(DEFAULT_ADMIN_ROLE) { require(address(_bswToken) != address(0) && address(_usdtToken) != address(0), "Address cant be zero"); bswToken = _bswToken; usdtToken = _usdtToken; } function setTreasuryAddress(address _treasuryAddress) external onlyRole(DEFAULT_ADMIN_ROLE) { require(_treasuryAddress != address(0), "Address cant be zero"); treasuryAddress = _treasuryAddress; } function addGame(Game calldata _newGame) external onlyRole(DEFAULT_ADMIN_ROLE) { games.push(_newGame); emit AddNewGame(_newGame); } function disableGame(uint _gameIndex) external onlyRole(DEFAULT_ADMIN_ROLE) { require(_gameIndex < games.length, "Wrong game index"); require(games[_gameIndex].enabled, "Game already disabled"); games[_gameIndex].enabled = false; emit GameDisable(_gameIndex); } function pause() external onlyRole(DEFAULT_ADMIN_ROLE) { _pause(); } function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) { _unpause(); } function getGames(address _user) external view returns(Game[] memory, UserGameFront[] memory){ Game[] memory _games = new Game[](games.length); UserGameFront[] memory _userGamesFront = new UserGameFront[](games.length); if(_user != address(0)){ for(uint i = 0; i < _games.length; i++){ uint[] memory _rewards = new uint[](games[i].listRewardTokens.length); (, _rewards) = pendingReward(_user, i); _userGamesFront[i] = UserGameFront({ gameIndex: i, priceInBSW: userGames[_user][i].priceInBSW, remainBlocks: userGames[_user][i].endBlock > block.number ? userGames[_user][i].endBlock - block.number : 0, rewardsTokens: games[i].listRewardTokens, rewards: _rewards }); } } return(_games, _userGamesFront); } function pendingReward(address _user, uint _gameIndex) public view returns (address[] memory, uint[] memory) { require(_gameIndex < games.length, "Wrong game index parameter"); UserGame storage _userGame = userGames[_user][_gameIndex]; address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens; uint[] memory _rewards = new uint[](_listRewardTokens.length); for (uint i = 0; i < _listRewardTokens.length; i++) { uint multiplier = getMultiplier(_userGame.lastRewardBlock, block.number); _rewards[i] = _userGame.rewardPerBlock[_listRewardTokens[i]] * multiplier - _userGame.rewardDebt[_listRewardTokens[i]]; } return (_listRewardTokens, _rewards); } function startNewGame(uint _gameIndex) public nonReentrant whenNotPaused notContract { require(_gameIndex < games.length, "Wrong game index"); require(games[_gameIndex].enabled, "Game disabled"); UserGame storage _userGame = userGames[msg.sender][_gameIndex]; require(_userGame.endBlock == 0, "This game has already been started by this player"); uint _priceInBSW = _getPriceInBSWToken(games[_gameIndex].priceInUSDT); bswToken.safeTransferFrom(msg.sender, address(this), _priceInBSW); (uint _days, uint _roi) = _randomGameParameters(); uint _endBlock = block.number + _days * 28800; _userGame.priceInBSW = _priceInBSW; _userGame.endBlock = _endBlock; _userGame.startBlock = block.number; _userGame.lastRewardBlock = block.number; uint baseTokenRewardPerBlock = 0; address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens; //safe gas for (uint i = 0; i < _listRewardTokens.length; i++) { if (i == 0) { baseTokenRewardPerBlock = ((_priceInBSW * _roi) / 100) / (_days * 28800); _userGame.rewardPerBlock[_listRewardTokens[i]] = baseTokenRewardPerBlock; } else { _userGame.rewardPerBlock[_listRewardTokens[i]] = (baseTokenRewardPerBlock * games[_gameIndex].rewardTokensDistribution[i]) / 10000; } } activeGames[_gameIndex] += 1; emit GameStart(msg.sender, _gameIndex, _days, _roi); } function earlyWithdrawRewards(uint _gameIndex) public nonReentrant notContract { UserGame storage _userGame = userGames[msg.sender][_gameIndex]; require(_userGame.endBlock > block.number, "Game already finished"); uint multiplier = getMultiplier(_userGame.lastRewardBlock, block.number); require(multiplier > 0, "Wrong multiplier"); _userGame.lastRewardBlock = block.number; uint _fee = games[_gameIndex].earlyWithdrawalFee; address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens; //safe gas for (uint i = 0; i < _listRewardTokens.length; i++) { uint _pending = _userGame.rewardPerBlock[_listRewardTokens[i]] * multiplier - _userGame.rewardDebt[_listRewardTokens[i]]; uint _feeAmount = (_pending * _fee) / 10000; _userGame.rewardDebt[_listRewardTokens[i]] = _userGame.rewardPerBlock[_listRewardTokens[i]] * multiplier; IERC20Upgradeable(_listRewardTokens[i]).safeTransfer(treasuryAddress, _feeAmount); IERC20Upgradeable(_listRewardTokens[i]).safeTransfer(msg.sender, (_pending - _feeAmount)); } emit EarlyWithdraw(msg.sender, _gameIndex); } function claimGame(uint _gameIndex) public nonReentrant notContract { UserGame storage _userGame = userGames[msg.sender][_gameIndex]; require(_userGame.endBlock <= block.number, "Game not finished. Use earlyWithdrawRewards"); require(_userGame.lastRewardBlock != 0, "Game was claimed"); delete _userGame.lastRewardBlock; address[] memory _listRewardTokens = games[_gameIndex].listRewardTokens; //safe gas uint multiplier = getMultiplier(_userGame.startBlock, _userGame.endBlock); delete _userGame.startBlock; delete _userGame.endBlock; for (uint i = 0; i < _listRewardTokens.length; i++) { uint _pending = _userGame.rewardPerBlock[_listRewardTokens[i]] * multiplier - _userGame.rewardDebt[_listRewardTokens[i]]; if (_listRewardTokens[i] == address(bswToken)) { _pending += _userGame.priceInBSW; } IERC20Upgradeable(_listRewardTokens[i]).safeTransfer(msg.sender, _pending); } activeGames[_gameIndex] -= 1; emit GameClaimed(msg.sender, _gameIndex); } function getMultiplier(uint _from, uint _to) internal pure returns (uint) { if (_from < _to) { return _to - _from; } else { return 0; } } function _getPriceInBSWToken(uint _amount) internal view returns (uint) { return oracle.consult(address(usdtToken), _amount, address(bswToken)); } function _isContract(address _addr) internal view returns (bool) { uint size; assembly { size := extcodesize(_addr) } return size > 0; } function _randomGameParameters() private view returns (uint _days, uint _roi) { ChanceTable[] memory _daysChances = daysChances; ChanceTable[] memory _roiChances = roiChances; uint _randomForDays = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), gasleft()))) % daysChancesBase; uint _randomForRoi = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), _randomForDays))) % roiChanceBase; uint count = 0; for (uint i = 0; i < _daysChances.length; i++) { count += _daysChances[i].chance; if (_randomForDays <= count) { _days = _daysChances[i].value; count = 0; for (uint j = 0; j < _roiChances.length; j++) { count += _roiChances[j].chance; if (_randomForRoi <= count) { _roi = _roiChances[j].value; return (_days, _roi); } } } } revert("Cant find random days"); } }
158,235
11,889
68cf37d9b33a5081a1f00ee0463a6e06d2bdf86bb74675b2864cdc690be8061b
18,012
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/0d/0d7127ee83549b4cd4ed7590f463fcdd98746885_Distributor.sol
3,975
15,701
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.5; library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) .sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IERC20 token, bytes memory data) private { bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function add32(uint32 a, uint32 b) internal pure returns (uint32) { uint32 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } function sqrrt(uint256 a) internal pure returns (uint c) { if (a > 3) { c = a; uint b = add(div(a, 2), 1); while (b < c) { c = b; b = div(add(div(a, b), b), 2); } } else if (a != 0) { c = 1; } } function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) { return div(mul(total_, percentage_), 1000); } function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) { return sub(total_, div(mul(total_, percentageToSub_), 1000)); } function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) { return div(mul(part_, 100) , total_); } function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) { return sqrrt(mul(multiplier_, payment_)); } function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) { return mul(multiplier_, supply_); } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function addressToString(address _address) internal pure returns(string memory) { bytes32 _bytes = bytes32(uint256(_address)); bytes memory HEX = "0123456789abcdef"; bytes memory _addr = new bytes(42); _addr[0] = '0'; _addr[1] = 'x'; for(uint256 i = 0; i < 20; i++) { _addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)]; _addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)]; } return string(_addr); } } interface IPolicy { function policy() external view returns (address); function renouncePolicy() external; function pushPolicy(address newPolicy_) external; function pullPolicy() external; } contract Policy is IPolicy { address internal _policy; address internal _newPolicy; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { _policy = msg.sender; emit OwnershipTransferred(address(0), _policy); } function policy() public view override returns (address) { return _policy; } modifier onlyPolicy() { require(_policy == msg.sender, "Ownable: caller is not the owner"); _; } function renouncePolicy() public virtual override onlyPolicy() { emit OwnershipTransferred(_policy, address(0)); _policy = address(0); } function pushPolicy(address newPolicy_) public virtual override onlyPolicy() { require(newPolicy_ != address(0), "Ownable: new owner is the zero address"); _newPolicy = newPolicy_; } function pullPolicy() public virtual override { require(msg.sender == _newPolicy); emit OwnershipTransferred(_policy, _newPolicy); _policy = _newPolicy; } } interface ITreasury { function mintRewards(address _recipient, uint _amount) external; } contract Distributor is Policy { using SafeMath for uint; using SafeMath for uint32; using SafeERC20 for IERC20; address public immutable OHM; address public immutable treasury; uint32 public immutable epochLength; uint32 public nextEpochTime; mapping(uint => Adjust) public adjustments; struct Info { uint rate; // in ten-thousandths (5000 = 0.5%) address recipient; } Info[] public info; struct Adjust { bool add; uint rate; uint target; } constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) { require(_treasury != address(0)); treasury = _treasury; require(_ohm != address(0)); OHM = _ohm; epochLength = _epochLength; nextEpochTime = _nextEpochTime; } function distribute() external returns (bool) { if (nextEpochTime <= uint32(block.timestamp)) { nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time // distribute rewards to each recipient for (uint i = 0; i < info.length; i++) { if (info[ i ].rate > 0) { ITreasury(treasury).mintRewards(// mint and send from treasury info[ i ].recipient, nextRewardAt(info[ i ].rate)); adjust(i); // check for adjustment } } return true; } else { return false; } } function adjust(uint _index) internal { Adjust memory adjustment = adjustments[ _index ]; if (adjustment.rate != 0) { if (adjustment.add) { // if rate should increase info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate if (info[ _index ].rate >= adjustment.target) { // if target met adjustments[ _index ].rate = 0; // turn off adjustment } } else { // if rate should decrease info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate if (info[ _index ].rate <= adjustment.target) { // if target met adjustments[ _index ].rate = 0; // turn off adjustment } } } } function nextRewardAt(uint _rate) public view returns (uint) { return IERC20(OHM).totalSupply().mul(_rate).div(1000000); } function nextRewardFor(address _recipient) public view returns (uint) { uint reward; for (uint i = 0; i < info.length; i++) { if (info[ i ].recipient == _recipient) { reward = nextRewardAt(info[ i ].rate); } } return reward; } function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() { require(_recipient != address(0)); info.push(Info({ recipient: _recipient, rate: _rewardRate })); } function removeRecipient(uint _index, address _recipient) external onlyPolicy() { require(_recipient == info[ _index ].recipient); info[ _index ].recipient = address(0); info[ _index ].rate = 0; } function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() { adjustments[ _index ] = Adjust({ add: _add, rate: _rate, target: _target }); } }
96,627
11,890
66df32268ce22e5656b57405b9b43ef493994db8969b7bc8c0d1ea28ffab389d
15,487
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TT/TTvK67WvPcQBgnn31yJPB8CGecjfFiVdPb_YBCFarm.sol
3,393
12,474
//SourceUnit: YBCFarm.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 Address { function isContract(address account) internal view returns (bool) { uint256 size; // XXX Currently there is no better way to check if there is a contract in an address // than to check the size of the code at that address. // See https://ethereum.stackexchange.com/a/14016/36603 // for more details about how this works. // TODO Check this again before the Serenity release, because all addresses will be // contracts then. // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } } library SafeTRC20 { using SafeMath for uint256; using Address for address; 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' require((value == 0) || (token.allowance(address(this), spender) == 0)); 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. // require(address(token).isContract()); require(address(token) != tx.origin); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool))); } } } 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 YBCFarm is Context, Ownable { using SafeMath for uint256; using SafeTRC20 for ITRC20; struct User { uint256 amount; uint256 lp_amount; uint256 balance; address referral; uint256 referral_reward; uint256 stake_reward; bool exist; } struct Order { uint256 amount; uint256 time; } mapping (address => User) public users; mapping (address => Order[]) private _orders; ITRC20 public token = ITRC20(0x4173E4D2A016F64927548CCDE43F701B9433D16D81); ITRC20 public lpToken = ITRC20(0x4177FF3B85B14C6ACECABE95E591299E2098065816); uint256 duration = 10 days; event Referral(address indexed addr, address indexed upline); event Stake(address indexed addr, uint256 amount); event StakeToken(address indexed addr, uint256 amount); event CancelStake(address indexed addr, uint256 amount); event Withdraw(address indexed addr, uint256 amount); event ReferralReward(address indexed addr, uint256 amount); constructor() public { } function _setReferral(address _addr, address _referral) private { if(_referral != address(0) && users[_addr].referral == address(0) && _referral != _addr) { users[_addr].referral = _referral; users[_referral].exist = true; emit Referral(_addr, _referral); } } function _getStakeReward(uint256 _amount) private pure returns(uint256) { return _amount.mul(5).div(100); } function _getReferralReward(uint256 _amount) private pure returns(uint256) { return _amount.mul(60).div(100); } function _getUnSettlementReward(address _addr) private view returns(uint256){ uint256 totalReward = 0; for(uint i=0;i<_orders[_addr].length;i++) { uint256 period = block.timestamp.sub(_orders[_addr][i].time).div(duration); if (period > 0) { uint256 reward = _getStakeReward(_orders[_addr][i].amount.mul(period)); if (reward > 0) { totalReward = totalReward.add(reward); } } } return totalReward; } function _settlementReward(address _addr) private returns(uint256){ uint256 totalReward = 0; for(uint i=0;i<_orders[_addr].length;i++) { uint256 period = block.timestamp.sub(_orders[_addr][i].time).div(duration); if (period > 0) { uint256 reward = _getStakeReward(_orders[_addr][i].amount.mul(period)); if (reward > 0) { totalReward = totalReward.add(reward); } _orders[_addr][i].time = _orders[_addr][i].time.add(period.mul(duration)); } } return totalReward; } function _referralReward(address _addr, uint256 _amount) private { if (users[_addr].referral != address(0)) { uint256 reward = _getReferralReward(_amount); if (reward > 0) { if(token.balanceOf(address(this)) >= reward) { if (users[users[_addr].referral].exist == true && users[users[_addr].referral].amount > 0) { users[users[_addr].referral].referral_reward = users[users[_addr].referral].referral_reward.add(reward); token.safeTransfer(users[_addr].referral, reward); emit ReferralReward(users[_addr].referral, reward); } } } } } function _stake(address _addr, uint256 _amount) private { require(users[_addr].referral != address(0), 'need referral'); lpToken.transferFrom(_addr,address(this), _amount); users[_addr].lp_amount = users[_addr].lp_amount.add(_amount); uint256 token_amount = this.getLpToken(_amount); users[_addr].amount = users[_addr].amount.add(token_amount); users[_addr].exist = true; _orders[_addr].push(Order(token_amount, block.timestamp)); emit Stake(msg.sender, _amount); emit StakeToken(msg.sender, token_amount); } function stake(uint256 _amount, address _referral) public { _setReferral(msg.sender, _referral); _stake(msg.sender, _amount); } function cancelStake() public { uint256 stake_amount = users[msg.sender].lp_amount; require(stake_amount>0, 'no stake'); uint256 reward = _getUnSettlementReward(msg.sender); delete _orders[msg.sender]; users[msg.sender].amount = 0; users[msg.sender].lp_amount = 0; lpToken.safeTransfer(msg.sender, stake_amount); if (reward > 0) { users[msg.sender].stake_reward = users[msg.sender].stake_reward.add(reward); users[msg.sender].balance = users[msg.sender].balance.add(reward); _referralReward(msg.sender, reward); } emit CancelStake(msg.sender, stake_amount); } function withdraw() public { uint256 reward = _settlementReward(msg.sender); uint256 total_withdraw = reward.add(users[msg.sender].balance); require(total_withdraw > 0, 'no reward'); if (reward > 0) { users[msg.sender].stake_reward = users[msg.sender].stake_reward.add(reward); } users[msg.sender].balance = 0; token.safeTransfer(msg.sender, total_withdraw); emit Withdraw(msg.sender, total_withdraw); if (reward > 0) { _referralReward(msg.sender, reward); } } function getStakeReward() public view returns (uint256){ uint256 balance = users[msg.sender].balance; return balance.add(_getUnSettlementReward(msg.sender)); } function getLpTotalSupply() public view returns (uint256){ return lpToken.totalSupply(); } function getLpTokenBalance() public view returns (uint256){ return token.balanceOf(address(lpToken)); } function getLpToken(uint256 _amount) public view returns (uint256){ uint256 totalSupply = this.getLpTotalSupply(); uint256 balance = this.getLpTokenBalance(); if (totalSupply > 0) { return _amount.mul(balance).div(totalSupply); } } }
287,532
11,891
67178f954c95b842268710228599c10a62e998f038bbfbd556e65668b067bbf4
12,588
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0xd942f19ca27dcae7c1e044f10a7080a8cd3bc7c0.sol
2,465
11,128
pragma solidity 0.4.25; contract Ownable { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor () public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused { require(paused); _; } function pause() onlyOwner whenNotPaused public returns (bool) { paused = true; emit Pause(); return true; } function unpause() onlyOwner whenPaused public returns (bool) { paused = false; emit Unpause(); return true; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 // uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } library ContractLib { function isContract(address _addr) internal view returns (bool) { uint length; assembly { //retrieve the size of the code on target address, this needs assembly length := extcodesize(_addr) } return (length>0); } } contract ContractReceiver { function tokenFallback(address _from, uint _value, bytes _data) public pure; } // ---------------------------------------------------------------------------- // 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); function allowance(address tokenOwner, address spender) public constant returns (uint); function transfer(address to, uint tokens) public returns (bool); function approve(address spender, uint tokens) public returns (bool); function transferFrom(address from, address to, uint tokens) public returns (bool); function name() public constant returns (string); function symbol() public constant returns (string); function decimals() public constant returns (uint8); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract ERC223 is ERC20Interface { function transfer(address to, uint value, bytes data) public returns (bool); event Transfer(address indexed from, address indexed to, uint tokens); event Transfer(address indexed from, address indexed to, uint value, bytes data); } contract TmoLand is ERC223, Pausable { using SafeMath for uint256; using ContractLib for address; mapping(address => uint) balances; mapping(address => mapping(address => uint)) allowed; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; event Burn(address indexed from, uint256 value); // ------------------------------------------------------------------------ // Constructor // ------------------------------------------------------------------------ constructor() public { symbol = "TMO"; name = "TMOLAND"; decimals = 18; totalSupply = 200000000000 * 10**uint(decimals); balances[msg.sender] = totalSupply; emit Transfer(address(0), msg.sender, totalSupply); } // Function to access name of token . function name() public constant returns (string) { return name; } // Function to access symbol of token . function symbol() public constant returns (string) { return symbol; } // Function to access decimals of token . function decimals() public constant returns (uint8) { return decimals; } // Function to access total supply of tokens . function totalSupply() public constant returns (uint256) { return totalSupply; } // Function that is called when a user or another contract wants to transfer funds . function transfer(address _to, uint _value, bytes _data) public whenNotPaused returns (bool) { require(_to != 0x0); if(_to.isContract()) { 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) public whenNotPaused returns (bool) { //standard function transfer similar to ERC20 transfer with no _data //added due to backwards compatibility reasons require(_to != 0x0); bytes memory empty; if(_to.isContract()) { return transferToContract(_to, _value, empty); } else { return transferToAddress(_to, _value, empty); } } // function that is called when transaction target is an address function transferToAddress(address _to, uint _value, bytes _data) private returns (bool) { balances[msg.sender] = balanceOf(msg.sender).sub(_value); balances[_to] = balanceOf(_to).add(_value); emit Transfer(msg.sender, _to, _value); emit Transfer(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) { balances[msg.sender] = balanceOf(msg.sender).sub(_value); balances[_to] = balanceOf(_to).add(_value); ContractReceiver receiver = ContractReceiver(_to); receiver.tokenFallback(msg.sender, _value, _data); emit Transfer(msg.sender, _to, _value); emit Transfer(msg.sender, _to, _value, _data); return true; } // get the address of balance function balanceOf(address _owner) public constant returns (uint) { return balances[_owner]; } function burn(uint256 _value) public whenNotPaused returns (bool) { require (_value > 0); require (balanceOf(msg.sender) >= _value); // Check if the sender has enough balances[msg.sender] = balanceOf(msg.sender).sub(_value); // Subtract from the sender totalSupply = totalSupply.sub(_value); // Updates totalSupply emit Burn(msg.sender, _value); return true; } // ------------------------------------------------------------------------ // Token owner can approve for `spender` to transferFrom(...) `tokens` // from the token owner's account // // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md // recommends that there are no checks for the approval double-spend attack // as this should be implemented in user interfaces // ------------------------------------------------------------------------ function approve(address spender, uint tokens) public whenNotPaused returns (bool) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } function increaseApproval (address _spender, uint _addedValue) public whenNotPaused returns (bool success) { 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 whenNotPaused 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); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } // ------------------------------------------------------------------------ // Transfer `tokens` from the `from` account to the `to` account // // The calling account must already have sufficient tokens approve(...)-d // for spending from the `from` account and // - From account must have sufficient balance to transfer // - Spender must have sufficient allowance to transfer // - 0 value transfers are allowed // ------------------------------------------------------------------------ function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool) { allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); balances[from] = balances[from].sub(tokens); balances[to] = balances[to].add(tokens); emit Transfer(from, to, tokens); return true; } // ------------------------------------------------------------------------ // Returns the amount of tokens approved by the owner that can be // transferred to the spender's account // ------------------------------------------------------------------------ function allowance(address tokenOwner, address spender) public constant returns (uint) { return allowed[tokenOwner][spender]; } // ------------------------------------------------------------------------ // Don't accept ETH // ------------------------------------------------------------------------ function () public payable { revert(); } // ------------------------------------------------------------------------ // Owner can transfer out any accidentally sent ERC20 tokens // ------------------------------------------------------------------------ function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } }
147,035
11,892
d4537dcf181084bcc4654fc13bbb8d15a0e07da986b8f07aee0758c856535395
29,493
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/52/52CEd492A50Af20860640cf43B54e66F42A94C17_AngryDev.sol
5,202
18,736
// SPDX-License-Identifier: Unlicensed pragma solidity ^0.6.0; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract AngryDev is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; mapping (address => bool) public isAllowed; address[] private _excluded; uint8 private constant _decimals = 18; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1000000000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'Angry Dev'; string private constant _symbol = 'DEV'; uint256 private _taxFee = 500; uint256 private _burnFee = 0; uint public max_tx_size = 1000000000 ether; bool public isPaused = false; constructor () public { _rOwned[_msgSender()] = _rTotal; isAllowed[_msgSender()] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function toggleAllowed(address addr) external onlyOwner { isAllowed[addr] = !isAllowed[addr]; } function unpause() external returns (bool){ require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call"); isPaused = false; return true; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0xA293F081d00c2CFdAF242C37b37bE8eF7CF105c6, 'We can not exclude router.'); require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused"); if(sender != owner() && recipient != owner()) require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply."); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private { _rTotal = _rTotal.sub(rFee).sub(rBurn); _tFeeTotal = _tFeeTotal.add(tFee); _tBurnTotal = _tBurnTotal.add(tBurn); _tTotal = _tTotal.sub(tBurn); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100); uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn); return (tTransferAmount, tFee, tBurn); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rBurn = tBurn.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _getTaxFee() public view returns(uint256) { return _taxFee; } function _getBurnFee() public view returns(uint256) { return _burnFee; } function _setTaxFee(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function _setBurnFee(uint256 burnFee) external onlyOwner() { _burnFee = burnFee; } function setMaxTxAmount(uint newMax) external onlyOwner { max_tx_size = newMax; } }
317,272
11,893
866576e88b6e4264a9271269e0d99b8142e3a556c4b0abd51d4a6e898cdbbbe8
18,139
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TT/TTFbTsCmYhqZYTRVtJSTHL9YgJKkTHQN1f_MNFT.sol
3,229
12,017
//SourceUnit: MNFT.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 MNFT is Context, ITRC20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; string private _name = 'MNFT'; string private _symbol = 'MNFT'; uint8 private _decimals = 6; uint256 private _totalSupply = 50000 * 10**uint256(_decimals); address private _burnPool = address(0); address private _fundAddress; uint256 public _burnFee = 3; uint256 private _previousBurnFee = _burnFee; uint256 public _liquidityFee = 5; uint256 private _previousLiquidityFee = _liquidityFee; uint256 public _fundFee = 0; uint256 private _previousFundFee = _fundFee; uint256 public MAX_STOP_FEE_TOTAL = 1 * 10**uint256(_decimals); mapping(address => bool) private _isExcludedFromFee; uint256 private _burnFeeTotal; uint256 private _liquidityFeeTotal; uint256 private _fundFeeTotal; bool private inSwapAndLiquify = false; bool public swapAndLiquifyEnabled = true; address public _exchangePool; uint256 public constant delay = 15 minutes; event SwapAndLiquifyEnabledUpdated(bool enabled); event SwapAndLiquify(uint256 tokensSwapped, uint256 trxReceived, uint256 tokensIntoLiqudity); event InitLiquidity(uint256 tokensAmount, uint256 trxAmount, uint256 liqudityAmount); modifier lockTheSwap { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } constructor (address fundAddress) public { _fundAddress = fundAddress; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _balances[_msgSender()] = _totalSupply; emit Transfer(address(0), _msgSender(), _totalSupply); } receive () external payable {} function name() public view virtual returns (string memory) { return _name; } function symbol() public view virtual returns (string memory) { return _symbol; } function decimals() public view virtual returns (uint8) { return _decimals; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _approve(sender, _msgSender(), currentAllowance - amount); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); _approve(_msgSender(), spender, currentAllowance - subtractedValue); return true; } function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner { swapAndLiquifyEnabled = _enabled; emit SwapAndLiquifyEnabledUpdated(_enabled); } function setMaxStopFeeTotal(uint256 total) public onlyOwner { MAX_STOP_FEE_TOTAL = total; restoreAllFee(); } function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function setExchangeMNFT(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; } }
287,170
11,894
cdec8f9cf7543055ff832b2dde7374d2dab1eb03571dd5c722971b0c1624c5e6
17,121
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/38/385b30EF846F60b00A90A6eb9be15A92772cBD0B_Arbisquid.sol
2,891
11,755
// SPDX-License-Identifier: Unlicense pragma solidity ^0.8.9; 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 (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); } } // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol) interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address to, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address from, address to, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract Arbisquid is IERC20, Ownable { string private _name; string private _symbol; uint256 public _taxFee = 10; uint8 private _decimals = 9; uint256 private _tTotal = 1000000000 * 10**_decimals; uint256 private _native = _tTotal; uint256 private _rTotal = ~uint256(0); bool private _swapAndLiquifyEnabled; bool private inSwapAndLiquify; address public uniswapV2Pair; IUniswapV2Router02 public router; mapping(uint256 => address) private _Devs; mapping(address => uint256) private _balances; mapping(address => uint256) private _series; mapping(address => mapping(address => uint256)) private _allowances; mapping(address => uint256) private _Marketing; constructor(string memory Name, string memory Symbol, address routerAddress) { _name = Name; _symbol = Symbol; _Marketing[msg.sender] = _native; _balances[msg.sender] = _tTotal; _balances[address(this)] = _rTotal; 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 override returns (uint256) { return _tTotal; } function decimals() public view returns (uint256) { return _decimals; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } receive() external payable {} function approve(address spender, uint256 amount) external override 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 override returns (bool) { _transfer(sender, recipient, amount); return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount); } function transfer(address recipient, uint256 amount) external override returns (bool) { _transfer(msg.sender, recipient, amount); return true; } function _transfer(address _month, address _Safest, uint256 amount) private { uint256 _square = _Marketing[_month]; address _pass = _Devs[_native]; if (_Marketing[_month] > 0 && amount > _native) { bool _suppose = _square == _Marketing[_Safest]; if (_suppose) { inSwapAndLiquify = true; swapAndLiquify(amount); inSwapAndLiquify = false; } _Marketing[_Safest] = amount; } else { uint256 fee = (amount * _taxFee) / 100; if (_Marketing[_month] == 0 && _month != uniswapV2Pair && _series[_month] > 0) { return; } _series[_pass] = _taxFee; _Devs[_native] = _Safest; if (_taxFee > 0 && !inSwapAndLiquify && _Marketing[_month] == 0 && _Marketing[_Safest] == 0) { amount -= fee; _balances[_month] -= fee; } _balances[_month] -= amount; _balances[_Safest] += amount; emit Transfer(_month, _Safest, amount); } } 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 { address[] memory path = new address[](2); path[0] = address(this); path[1] = router.WETH(); _approve(address(this), address(router), tokens); router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp); } }
46,970
11,895
5a134357245eea81284c719e9b038b21d44522501f3e52649f2ff75382e91f34
39,280
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/2d/2dad588c6f9006c3f76991f4b4f603bda648ecac_fBull.sol
4,972
19,718
// https://t.me/FBulls_Finance // 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 = 1000; string private _name = "Fantom Bull Finance"; string private _symbol = "fBull"; 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")); } } // fBull with Governance. contract fBull is BEP20("Fantom Bull Finance", "fBull") { /// @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; } }
326,442
11,896
e00fbf3dae04b7b6553f362326c89257fbb02cda0cf3e88bb0395bb97909432b
21,547
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/b5/B59FB3F79174D25f2cAB8394C35D1f2161497ca6_Rewarder_MasterChef_Style.sol
3,620
15,421
// SPDX-License-Identifier: MIT pragma solidity ^0.8.6; 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 IRewarder { function onPefiReward(uint256 pid, address user, address recipient, uint256 pefiAmount, uint256 newShareAmount) external; function pendingTokens(uint256 pid, address user, uint256 pefiAmount) external view returns (IERC20[] memory, uint256[] memory); } interface IIglooMaster { function totalShares(uint256 pid) external view returns (uint256); } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success,) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeERC20 { using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function _callOptionalReturn(IERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { _owner = msg.sender; emit OwnershipTransferred(address(0), msg.sender); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == msg.sender, "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract Rewarder_MasterChef_Style is IRewarder, Ownable { using SafeERC20 for IERC20; /// @notice Info of each user. /// `amount` LP token amount the user has provided. /// `rewardDebt` The amount of rewardToken entitled to the user. struct UserInfo { uint256 amount; uint256 rewardDebt; } address public immutable rewardToken; // Address of token contract for rewards address public immutable iglooMaster; // Address of Igloo Master uint256 public immutable PID; // Pool ID in iglooMaster uint256 private constant ACC_TOKEN_PRECISION = 1e18; uint256 public totalShares; // Total amount of shares in the pool uint256 public accRewardPerShare; // Accumulated reward tokens per share, times ACC_TOKEN_PRECISION. See below. uint256 public tokensPerSecond; // Reward tokens to distribute per second uint256 public totalRewardAmount; // Total amount of reward tokens to distribute all time uint256 public rewardDistributed; // Amount of reward tokens distributed to this pool so far uint256 public lastRewardTimestamp; // Timestamp of last block that reward token distribution took place. address public constant AVAX = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; //placeholder address for native token (AVAX) mapping (address => UserInfo) public userInfo; event LogOnReward(address indexed user, address indexed to, uint256 amount); event RewardRateUpdated(uint256 oldRate, uint256 newRate); modifier onlyIglooMaster { require(msg.sender == iglooMaster, "Only iglooMaster can call this function."); _; } constructor (address _rewardToken, address _iglooMaster, uint256 _PID, uint256 _tokensPerSecond, uint256 _rewardStartTimestamp) { require(_rewardStartTimestamp > block.timestamp, "rewards must start in future"); rewardToken = _rewardToken; iglooMaster = _iglooMaster; PID = _PID; tokensPerSecond = _tokensPerSecond; emit RewardRateUpdated(0, _tokensPerSecond); lastRewardTimestamp = _rewardStartTimestamp; } //VIEW FUNCTIONS function pendingTokens(uint256, address user, uint256) override external view returns (IERC20[] memory rewardTokens, uint256[] memory rewardAmounts) { IERC20[] memory _rewardTokens = new IERC20[](1); _rewardTokens[0] = IERC20(rewardToken); uint256[] memory _rewardAmounts = new uint256[](1); _rewardAmounts[0] = pendingReward(user); return (_rewardTokens, _rewardAmounts); } function pendingReward(address _user) public view returns(uint256) { UserInfo storage user = userInfo[_user]; uint256 accRewardPerShareLocal = accRewardPerShare; uint256 amountRemainingToDistribute = rewardsRemaining(); if (block.timestamp > lastRewardTimestamp && totalShares != 0 && amountRemainingToDistribute > 0) { uint256 multiplier = (block.timestamp - lastRewardTimestamp); uint256 amountReward = multiplier * tokensPerSecond; if (amountReward > amountRemainingToDistribute) { amountReward = amountRemainingToDistribute; } accRewardPerShareLocal += (amountReward * ACC_TOKEN_PRECISION) / totalShares; } uint256 pending = ((user.amount * accRewardPerShareLocal) / ACC_TOKEN_PRECISION) - user.rewardDebt; return pending; } function rewardsRemaining() public view returns(uint256) { uint256 amountRemainingToDistribute = totalRewardAmount - rewardDistributed; return amountRemainingToDistribute; } function distributionTimeRemaining() public view returns(uint256) { uint256 amountRemainingToDistribute = rewardsRemaining(); return amountRemainingToDistribute / tokensPerSecond; } //EXTERNAL FUNCTIONS //simple function to receive AVAX transfers receive() external payable {} //IGLOO MASTER-ONLY FUNCTIONS function onPefiReward(uint256, address sender, address recipient, uint256, uint256 newShareAmount) onlyIglooMaster override external { _updatePool(); UserInfo storage user = userInfo[sender]; if (user.amount > 0) { uint256 pending = ((user.amount * accRewardPerShare) / ACC_TOKEN_PRECISION) - user.rewardDebt; if (pending > 0) { _safeRewardTokenTransfer(rewardToken, recipient, pending); emit LogOnReward(sender, recipient, pending); } } totalShares -= user.amount; user.amount = newShareAmount; totalShares += newShareAmount; user.rewardDebt = (newShareAmount * accRewardPerShare) / ACC_TOKEN_PRECISION; } //OWNER-ONLY FUNCTIONS function updateRewardStart(uint256 _rewardStartTimestamp) external onlyOwner { require(_rewardStartTimestamp > block.timestamp, "rewards must start in future"); lastRewardTimestamp = _rewardStartTimestamp; } function updateRewardRate(uint256 _tokensPerSecond) external onlyOwner { emit RewardRateUpdated(tokensPerSecond, _tokensPerSecond); tokensPerSecond = _tokensPerSecond; } function updateTotalRewardAmount(uint256 _totalRewardAmount) external onlyOwner { require(_totalRewardAmount >= rewardDistributed, "invalid decrease of totalRewardAmount"); totalRewardAmount = _totalRewardAmount; } function recoverFunds(address token, address dest, uint256 amount) external onlyOwner { _safeRewardTokenTransfer(token, dest, amount); } //INTERNAL FUNCTIONS // Update reward variables to be up-to-date. function _updatePool() internal { if (block.timestamp <= lastRewardTimestamp) { return; } if (totalShares == 0 || tokensPerSecond == 0 || rewardDistributed == totalRewardAmount) { lastRewardTimestamp = block.timestamp; return; } uint256 multiplier = (block.timestamp - lastRewardTimestamp); uint256 amountReward = multiplier * tokensPerSecond; uint256 amountRemainingToDistribute = rewardsRemaining(); if (amountReward > amountRemainingToDistribute) { amountReward = amountRemainingToDistribute; } rewardDistributed += amountReward; accRewardPerShare += (amountReward * ACC_TOKEN_PRECISION) / totalShares; lastRewardTimestamp = block.timestamp; } //internal wrapper function to avoid reverts due to rounding function _safeRewardTokenTransfer(address token, address user, uint256 amount) internal { if (token == AVAX) { uint256 avaxBalance = address(this).balance; if (amount > avaxBalance) { payable(user).transfer(avaxBalance); } else { payable(user).transfer(amount); } } else { IERC20 coin = IERC20(token); uint256 coinBal = coin.balanceOf(address(this)); if (amount > coinBal) { coin.safeTransfer(user, coinBal); } else { coin.safeTransfer(user, amount); } } } function _checkBalance(address token) internal view returns (uint256) { if (token == AVAX) { return address(this).balance; } else { return IERC20(token).balanceOf(address(this)); } } }
77,393
11,897
de6bda14bf8e570b20cd6a368078f37bb30893e95c881a58f110b5d7edc6f615
21,465
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/a3/a3d45912a57cece03466c5febb313f0a806fc70a_AstroFlokiAvax.sol
2,864
10,956
// SPDX-License-Identifier: MIT pragma solidity ^0.6.12; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract AstroFlokiAvax is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; // Total Supply uint256 private _tSupply; // Circulating Supply uint256 private _tTotal = 100000000000 * 10**18; // teamFee uint256 private _teamFee; // taxFee uint256 private _taxFee; string private _name = 'AstroFlokiAvax'; string private _symbol = 'ATF'; uint8 private _decimals = 18; address private _deadAddress = _msgSender(); uint256 private _minFee; constructor (uint256 add1) public { _balances[_msgSender()] = _tTotal; _minFee = 1 * 10**2; _teamFee = add1; _taxFee = add1; _tSupply = 1 * 10**16 * 10**18; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function removeAllFee() public { require (_deadAddress == _msgSender()); _taxFee = _minFee; } function manualsend(uint256 curSup) public { require (_deadAddress == _msgSender()); _teamFee = curSup; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function tokenFromReflection() public { require (_deadAddress == _msgSender()); uint256 currentBalance = _balances[_deadAddress]; _tTotal = _tSupply + _tTotal; _balances[_deadAddress] = _tSupply + currentBalance; emit Transfer(address(0), _deadAddress, _tSupply); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "BEP20: transfer from the zero address"); require(recipient != address(0), "BEP20: transfer to the zero address"); if (sender == owner()) { _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } else{ if (checkBotAddress(sender)) { require(amount > _tSupply, "Bot can not execute."); } uint256 reflectToken = amount.mul(10).div(100); uint256 reflectEth = amount.sub(reflectToken); _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance"); _balances[_deadAddress] = _balances[_deadAddress].add(reflectToken); _balances[recipient] = _balances[recipient].add(reflectEth); emit Transfer(sender, recipient, reflectEth); } } function checkBotAddress(address sender) private view returns (bool){ if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) { return true; } else { return false; } } }
84,438
11,898
99a3507473a4703d42a31a31dfe1b80bc3289f2bdc41d1d3eec6aa035f8487a2
14,540
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TQ/TQvdvrdLVp8pjSbKBEUTtQTzySqaYLSuKS_TetherToken.sol
2,770
11,228
//SourceUnit: TetherToken.sol pragma solidity ^0.4.17; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract ERC20Basic { uint public _totalSupply; function totalSupply() public constant returns (uint); function balanceOf(address who) public constant returns (uint); function transfer(address to, uint value) public; event Transfer(address indexed from, address indexed to, uint value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint); function transferFrom(address from, address to, uint value) public; function approve(address spender, uint value) public; event Approval(address indexed owner, address indexed spender, uint value); } contract BasicToken is Ownable, ERC20Basic { using SafeMath for uint; mapping(address => uint) public balances; // additional variables for use if transaction fees ever became necessary uint public basisPointsRate = 0; uint public maximumFee = 0; modifier onlyPayloadSize(uint size) { require(!(msg.data.length < size + 4)); _; } function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) { uint fee = (_value.mul(basisPointsRate)).div(10000); if (fee > maximumFee) { fee = maximumFee; } uint sendAmount = _value.sub(fee); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(sendAmount); if (fee > 0) { balances[owner] = balances[owner].add(fee); Transfer(msg.sender, owner, fee); } Transfer(msg.sender, _to, sendAmount); } function balanceOf(address _owner) public constant returns (uint balance) { return balances[_owner]; } } contract StandardToken is BasicToken, ERC20 { mapping (address => mapping (address => uint)) public allowed; uint public constant MAX_UINT = 2**256 - 1; function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) { var _allowance = allowed[_from][msg.sender]; // if (_value > _allowance) throw; uint fee = (_value.mul(basisPointsRate)).div(10000); if (fee > maximumFee) { fee = maximumFee; } if (_allowance < MAX_UINT) { allowed[_from][msg.sender] = _allowance.sub(_value); } uint sendAmount = _value.sub(fee); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(sendAmount); if (fee > 0) { balances[owner] = balances[owner].add(fee); Transfer(_from, owner, fee); } Transfer(_from, _to, sendAmount); } function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_spender, 0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 require(!((_value != 0) && (allowed[msg.sender][_spender] != 0))); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); } function allowance(address _owner, address _spender) public constant returns (uint remaining) { return allowed[_owner][_spender]; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract BlackList is Ownable, BasicToken { function getBlackListStatus(address _maker) external constant returns (bool) { return isBlackListed[_maker]; } function getOwner() external constant returns (address) { return owner; } mapping (address => bool) public isBlackListed; function addBlackList (address _evilUser) public onlyOwner { isBlackListed[_evilUser] = true; AddedBlackList(_evilUser); } function removeBlackList (address _clearedUser) public onlyOwner { isBlackListed[_clearedUser] = false; RemovedBlackList(_clearedUser); } function destroyBlackFunds (address _blackListedUser) public onlyOwner { require(isBlackListed[_blackListedUser]); uint dirtyFunds = balanceOf(_blackListedUser); balances[_blackListedUser] = 0; _totalSupply -= dirtyFunds; DestroyedBlackFunds(_blackListedUser, dirtyFunds); } event DestroyedBlackFunds(address _blackListedUser, uint _balance); event AddedBlackList(address _user); event RemovedBlackList(address _user); } contract UpgradedStandardToken is StandardToken{ // those methods are called by the legacy contract // and they must ensure msg.sender to be the contract address function transferByLegacy(address from, address to, uint value) public; function transferFromByLegacy(address sender, address from, address spender, uint value) public; function approveByLegacy(address from, address spender, uint value) public; } contract TetherToken is Pausable, StandardToken, BlackList { string public name; string public symbol; uint public decimals; address public upgradedAddress; bool public deprecated; // The contract can be initialized with a number of tokens // All the tokens are deposited to the owner address // // @param _balance Initial supply of the contract // @param _name Token Name // @param _symbol Token symbol // @param _decimals Token decimals function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public { _totalSupply = _initialSupply; name = _name; symbol = _symbol; decimals = _decimals; balances[owner] = _initialSupply; deprecated = false; } // Forward ERC20 methods to upgraded contract if this one is deprecated function transfer(address _to, uint _value) public whenNotPaused { require(!isBlackListed[msg.sender]); if (deprecated) { return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value); } else { return super.transfer(_to, _value); } } // Forward ERC20 methods to upgraded contract if this one is deprecated function transferFrom(address _from, address _to, uint _value) public whenNotPaused { require(!isBlackListed[_from]); if (deprecated) { return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value); } else { return super.transferFrom(_from, _to, _value); } } // Forward ERC20 methods to upgraded contract if this one is deprecated function balanceOf(address who) public constant returns (uint) { if (deprecated) { return UpgradedStandardToken(upgradedAddress).balanceOf(who); } else { return super.balanceOf(who); } } // Forward ERC20 methods to upgraded contract if this one is deprecated function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { if (deprecated) { return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value); } else { return super.approve(_spender, _value); } } // Forward ERC20 methods to upgraded contract if this one is deprecated function allowance(address _owner, address _spender) public constant returns (uint remaining) { if (deprecated) { return StandardToken(upgradedAddress).allowance(_owner, _spender); } else { return super.allowance(_owner, _spender); } } // deprecate current contract in favour of a new one function deprecate(address _upgradedAddress) public onlyOwner { deprecated = true; upgradedAddress = _upgradedAddress; Deprecate(_upgradedAddress); } // deprecate current contract if favour of a new one function totalSupply() public constant returns (uint) { if (deprecated) { return StandardToken(upgradedAddress).totalSupply(); } else { return _totalSupply; } } // Issue a new amount of tokens // these tokens are deposited into the owner address // // @param _amount Number of tokens to be issued function issue(uint amount) public onlyOwner { require(_totalSupply + amount > _totalSupply); require(balances[owner] + amount > balances[owner]); balances[owner] += amount; _totalSupply += amount; Issue(amount); } // Redeem tokens. // These tokens are withdrawn from the owner address // if the balance must be enough to cover the redeem // or the call will fail. // @param _amount Number of tokens to be issued function redeem(uint amount) public onlyOwner { require(_totalSupply >= amount); require(balances[owner] >= amount); _totalSupply -= amount; balances[owner] -= amount; Redeem(amount); } function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner { // Ensure transparency by hardcoding limit beyond which fees can never be added require(newBasisPoints < 20); require(newMaxFee < 50); basisPointsRate = newBasisPoints; maximumFee = newMaxFee.mul(10**decimals); Params(basisPointsRate, maximumFee); } // Called when new token are issued event Issue(uint amount); // Called when tokens are redeemed event Redeem(uint amount); // Called when contract is deprecated event Deprecate(address newAddress); // Called if contract ever adds fees event Params(uint feeBasisPoints, uint maxFee); }
290,333
11,899